1 /* ************************************************************************
2  * Copyright 2014 Advanced Micro Devices, Inc.
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  * ************************************************************************/
16 
17 #ifndef _CLBLAS_FUNCTOR_XGEMM_H_
18 #define _CLBLAS_FUNCTOR_XGEMM_H_
19 
20 //
21 // This file provides the declarations of all XGEMM functors and related classes.
22 //
23 //
24 //
25 
26 
27 #include "functor.h"
28 
29 
30 //
31 // Base class for all XGEMM functors (DGEMM, SGEMM, ...)
32 //
33 template <class T>
34 class clblasXgemmFunctor : public clblasFunctor
35 {
36   public:
37 
38     // Structure used to store all XGEMM arguments
39     struct Args
40     {
41         clblasOrder      order;
42         clblasTranspose  transA;
43         clblasTranspose  transB;
44         size_t           M;
45         size_t           N;
46         size_t           K;
47         T                alpha;
48         cl_mem           A;
49         size_t           offA;
50         size_t           lda;
51         cl_mem           B;
52         size_t           offB;
53         size_t           ldb;
54         T                beta;
55         cl_mem           C;
56         size_t           offC;
57         size_t           ldc;
58         cl_command_queue queue;
59         cl_uint          numEventsInWaitList;
60         const cl_event * eventWaitList;
61         cl_event *       events;
62 
ArgsArgs63         Args(clblasOrder order,
64              clblasTranspose transA,
65              clblasTranspose transB,
66              size_t M,
67              size_t N,
68              size_t K,
69              T alpha,
70              cl_mem A,
71              size_t offA,
72              size_t lda,
73              cl_mem B,
74              size_t offB,
75              size_t ldb,
76              T beta,
77              cl_mem C,
78              size_t offC,
79              size_t ldc,
80              cl_command_queue queue,
81              cl_uint numEventsInWaitList,
82              const cl_event *eventWaitList,
83              cl_event *events)
84             : order(order),
85               transA(transA),
86               transB(transB),
87               M(M),
88               N(N),
89               K(K),
90               alpha(alpha),
91               A(A),
92               offA(offA),
93               lda(lda),
94               B(B),
95               offB(offB),
96               ldb(ldb),
97               beta(beta),
98               C(C),
99               offC(offC),
100               ldc(ldc),
101               queue(queue),
102               numEventsInWaitList(numEventsInWaitList),
103               eventWaitList(eventWaitList),
104               events(events)
105         {
106         }
107     };
108 
109 public:
110 
111     virtual clblasStatus execute(Args &args) = 0;
112 
113 } ;
114 
115 // ================  SGEMM ==================
116 
117 //
118 // Base class for all functors providing a SGEMM implementation
119 //
120 class clblasSgemmFunctor : public clblasXgemmFunctor<cl_float>
121 {
122 };
123 
124 //
125 // Fallback functor for SGEMM using the original solver mechanism
126 //
127 class clblasSgemmFunctorFallback : public clblasSgemmFunctor
128 {
129 public:   // Inherited members from clblasFunctor
130     virtual void retain();
131     virtual void release();
132  public:  // Inherited members from clblasSgemmFunctor
133     virtual clblasStatus execute(Args & a);
134  public:
135     static clblasSgemmFunctorFallback * provide ();
136 };
137 
138 
139 
140 // ================  DGEMM ==================
141 
142 //
143 //
144 // Base class for all functors providing a DGEMM implementation
145 //
146 class clblasDgemmFunctor : public clblasXgemmFunctor<cl_double>
147 {
148 };
149 
150 //
151 // Fallback functor for DGEMM using the original solver mechanism
152 //
153 class clblasDgemmFunctorFallback : public clblasDgemmFunctor
154 {
155 public:   // Inherited members from clblasFunctor
156     virtual void retain();
157     virtual void release();
158  public:  // Inherited members from clblasDgemmFunctor
159     virtual clblasStatus execute(Args & a);
160  public:
161     static clblasDgemmFunctorFallback * provide ();
162 };
163 
164 
165 // ================  CGEMM ==================
166 
167 //
168 // Base class for all functors providing a CGEMM implementation
169 //
170 class clblasCgemmFunctor : public clblasXgemmFunctor<FloatComplex>
171 {
172 };
173 
174 //
175 // Fallback functor for CGEMM using the original solver mechanism
176 //
177 class clblasCgemmFunctorFallback : public clblasCgemmFunctor
178 {
179 public:   // Inherited members from clblasFunctor
180     virtual void retain();
181     virtual void release();
182  public:  // Inherited members from clblasCgemmFunctor
183     virtual clblasStatus execute(Args & a);
184  public:
185     static clblasCgemmFunctorFallback * provide ();
186 };
187 
188 
189 // ================  ZGEMM ==================
190 
191 //
192 // Base class for all functors providing a ZGEMM implementation
193 //
194 class clblasZgemmFunctor : public clblasXgemmFunctor<DoubleComplex>
195 {
196 };
197 
198 //
199 // Fallback functor for ZGEMM using the original solver mechanism
200 //
201 class clblasZgemmFunctorFallback : public clblasZgemmFunctor
202 {
203 public:   // Inherited members from clblasFunctor
204     virtual void retain();
205     virtual void release();
206  public:  // Inherited members from clblasZgemmFunctor
207     virtual clblasStatus execute(Args & a);
208  public:
209     static clblasZgemmFunctorFallback * provide ();
210 };
211 
212 
213 #endif // _CLBLAS_FUNCTOR_XGEMM_H_
214