1 /*
2 * Copyright (c) 2024, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25 #include "shared.h"
26
27 #define INFO 0
28
29
30 void hexdump(void *ptr, int buflen) {
31 unsigned char *buf = (unsigned char *) ptr;
32 int i, j;
33 for (i = 0; i < buflen; i += 16) {
34 printf("%06x: ", i);
35 for (j = 0; j < 16; j++)
36 if (i + j < buflen)
37 printf("%02x ", buf[i + j]);
38 else
39 printf(" ");
40 printf(" ");
41 for (j = 0; j < 16; j++)
42 if (i + j < buflen)
43 printf("%c", isprint(buf[i + j]) ? buf[i + j] : '.');
44 printf("\n");
45 }
46 }
47
48 void Sled::show(std::ostream &out, void *argArray) {
49 ArgSled argSled(static_cast<ArgArray_s *>(argArray));
50 for (int i = 0; i < argSled.argc(); i++) {
51 Arg_s *arg = argSled.arg(i);
52 switch (arg->variant) {
53 case '&': {
54 out << "Buf: of " << arg->value.buffer.sizeInBytes << " bytes " << std::endl;
55 break;
56 }
57 case 'B': {
58 out << "S8:" << arg->value.s8 << std::endl;
59 break;
60 }
61 case 'Z': {
62 out << "Z:" << arg->value.z1 << std::endl;
63 break;
64 }
65 case 'C': {
66 out << "U16:" << arg->value.u16 << std::endl;
67 break;
68 }
69 case 'S': {
70 out << "S16:" << arg->value.s16 << std::endl;
71 break;
72 }
73 case 'I': {
74 out << "S32:" << arg->value.s32 << std::endl;
75 break;
76 }
77 case 'F': {
78 out << "F32:" << arg->value.f32 << std::endl;
79 break;
80 }
81 case 'J': {
82 out << "S64:" << arg->value.s64 << std::endl;
83 break;
84 }
85 case 'D': {
86 out << "F64:" << arg->value.f64 << std::endl;
87 break;
88 }
89 default: {
90 std::cerr << "unexpected variant (shared.cpp) '" << (char) arg->variant << "'" << std::endl;
91 exit(1);
92 }
93 }
94 }
95 out << "schema len = " << argSled.schemaLen() << std::endl;
96
97 out << "schema = " << argSled.schema() << std::endl;
98 }
99
100
101 extern "C" int getMaxComputeUnits(long backendHandle) {
102 if (INFO){
103 std::cout << "trampolining through backendHandle to backend.getMaxComputeUnits()" << std::endl;
104 }
105 auto *backend = reinterpret_cast<Backend*>(backendHandle);
106 return backend->getMaxComputeUnits();
107 }
108
109 extern "C" void info(long backendHandle) {
110 if (INFO){
111 std::cout << "trampolining through backendHandle to backend.info()" << std::endl;
112 }
113 auto *backend = reinterpret_cast<Backend*>(backendHandle);
114 backend->info();
115 }
116 extern "C" void computeStart(long backendHandle) {
117 if (INFO){
118 std::cout << "trampolining through backendHandle to backend.computeStart()" << std::endl;
119 }
120 auto *backend = reinterpret_cast<Backend*>(backendHandle);
121 backend->computeStart();
122 }
123 extern "C" void computeEnd(long backendHandle) {
124 if (INFO){
125 std::cout << "trampolining through backendHandle to backend.computeEnd()" << std::endl;
126 }
127 auto *backend = reinterpret_cast<Backend*>(backendHandle);
128 backend->computeEnd();
129 }
130 extern "C" void releaseBackend(long backendHandle) {
131 auto *backend = reinterpret_cast<Backend*>(backendHandle);
132 delete backend;
133 }
134 extern "C" long compileProgram(long backendHandle, int len, char *source) {
135 if (INFO){
136 std::cout << "trampolining through backendHandle to backend.compileProgram() "
137 <<std::hex<<backendHandle<< std::dec <<std::endl;
138 }
139 auto *backend = reinterpret_cast<Backend*>(backendHandle);
140 auto programHandle = backend->compileProgram(len, source);
141 if (INFO){
142 std::cout << "programHandle = "<<std::hex<<backendHandle<< std::dec <<std::endl;
143 }
144 return programHandle;
145 }
146 extern "C" long getKernel(long programHandle, int nameLen, char *name) {
147 if (INFO){
148 std::cout << "trampolining through programHandle to program.getKernel()"
149 <<std::hex<<programHandle<< std::dec <<std::endl;
150 }
151 auto program = reinterpret_cast<Backend::Program *>(programHandle);
152 return program->getKernel(nameLen, name);
153 }
154
155 extern "C" long ndrange(long kernelHandle, void *argArray) {
156 if (INFO){
157 std::cout << "trampolining through kernelHandle to kernel.ndrange(...) " << std::endl;
158 }
159 auto kernel = reinterpret_cast<Backend::Program::Kernel *>(kernelHandle);
160 kernel->ndrange( argArray);
161 return (long) 0;
162 }
163 extern "C" void releaseKernel(long kernelHandle) {
164 if (INFO){
165 std::cout << "trampolining through to releaseKernel " << std::endl;
166 }
167 auto kernel = reinterpret_cast<Backend::Program::Kernel *>(kernelHandle);
168 delete kernel;
169 }
170
171 extern "C" void releaseProgram(long programHandle) {
172 if (INFO){
173 std::cout << "trampolining through to releaseProgram " << std::endl;
174 }
175 auto program = reinterpret_cast<Backend::Program *>(programHandle);
176 delete program;
177 }
178 extern "C" bool programOK(long programHandle) {
179 if (INFO){
180 std::cout << "trampolining through to programOK " << std::endl;
181 }
182 auto program = reinterpret_cast<Backend::Program *>(programHandle);
183 return program->programOK();
184 }
185
186 extern "C" bool getBufferFromDeviceIfDirty(long backendHandle, long memorySegmentHandle, long memorySegmentLength) {
187 if (INFO){
188 std::cout << "trampolining through to getBuffer " << std::endl;
189 }
190 auto backend = reinterpret_cast<Backend *>(backendHandle);
191 auto memorySegment = reinterpret_cast<void *>(memorySegmentHandle);
192 return backend->getBufferFromDeviceIfDirty(memorySegment, memorySegmentLength);
193 }
194
195