1 //===- RunnerUtils.cpp - Utils for MLIR exec on targets with a C++ runtime ===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 // 9 // This file implements basic functions to debug structured MLIR types at 10 // runtime. Entities in this file may not be compatible with targets without a 11 // C++ runtime. These may be progressively migrated to CRunnerUtils.cpp over 12 // time. 13 // 14 //===----------------------------------------------------------------------===// 15 16 #include "mlir/ExecutionEngine/RunnerUtils.h" 17 #include <chrono> 18 19 #ifdef _MSC_VER 20 #include "malloc.h" 21 #endif 22 23 // NOLINTBEGIN(*-identifier-naming) 24 25 extern "C" void *_mlir_alloc(uint64_t size) { return malloc(size); } 26 27 extern "C" void *_mlir_aligned_alloc(uint64_t alignment, uint64_t size) { 28 #ifdef _MSC_VER 29 return _aligned_malloc(size, alignment); 30 #else 31 return aligned_alloc(alignment, size); 32 #endif 33 } 34 35 extern "C" void _mlir_free(void *ptr) { free(ptr); } 36 37 extern "C" void _mlir_aligned_free(void *ptr) { 38 #ifdef _MSC_VER 39 _aligned_free(ptr); 40 #else 41 free(ptr); 42 #endif 43 } 44 45 extern "C" void _mlir_ciface_printMemrefShapeI8(UnrankedMemRefType<int8_t> *M) { 46 std::cout << "Unranked Memref "; 47 printMemRefMetaData(std::cout, DynamicMemRefType<int8_t>(*M)); 48 std::cout << "\n"; 49 } 50 51 extern "C" void 52 _mlir_ciface_printMemrefShapeI32(UnrankedMemRefType<int32_t> *M) { 53 std::cout << "Unranked Memref "; 54 printMemRefMetaData(std::cout, DynamicMemRefType<int32_t>(*M)); 55 std::cout << "\n"; 56 } 57 58 extern "C" void 59 _mlir_ciface_printMemrefShapeI64(UnrankedMemRefType<int64_t> *M) { 60 std::cout << "Unranked Memref "; 61 printMemRefMetaData(std::cout, DynamicMemRefType<int64_t>(*M)); 62 std::cout << "\n"; 63 } 64 65 extern "C" void _mlir_ciface_printMemrefShapeF32(UnrankedMemRefType<float> *M) { 66 std::cout << "Unranked Memref "; 67 printMemRefMetaData(std::cout, DynamicMemRefType<float>(*M)); 68 std::cout << "\n"; 69 } 70 71 extern "C" void 72 _mlir_ciface_printMemrefShapeF64(UnrankedMemRefType<double> *M) { 73 std::cout << "Unranked Memref "; 74 printMemRefMetaData(std::cout, DynamicMemRefType<double>(*M)); 75 std::cout << "\n"; 76 } 77 78 extern "C" void _mlir_ciface_printMemrefVector4x4xf32( 79 StridedMemRefType<Vector2D<4, 4, float>, 2> *M) { 80 impl::printMemRef(*M); 81 } 82 83 extern "C" void _mlir_ciface_printMemrefI8(UnrankedMemRefType<int8_t> *M) { 84 impl::printMemRef(*M); 85 } 86 87 extern "C" void _mlir_ciface_printMemrefI32(UnrankedMemRefType<int32_t> *M) { 88 impl::printMemRef(*M); 89 } 90 91 extern "C" void _mlir_ciface_printMemrefI64(UnrankedMemRefType<int64_t> *M) { 92 impl::printMemRef(*M); 93 } 94 95 extern "C" void _mlir_ciface_printMemrefF32(UnrankedMemRefType<float> *M) { 96 impl::printMemRef(*M); 97 } 98 99 extern "C" void _mlir_ciface_printMemrefF64(UnrankedMemRefType<double> *M) { 100 impl::printMemRef(*M); 101 } 102 103 extern "C" int64_t _mlir_ciface_nanoTime() { 104 auto now = std::chrono::high_resolution_clock::now(); 105 auto duration = now.time_since_epoch(); 106 auto nanoseconds = 107 std::chrono::duration_cast<std::chrono::nanoseconds>(duration); 108 return nanoseconds.count(); 109 } 110 111 extern "C" void printMemrefI32(int64_t rank, void *ptr) { 112 UnrankedMemRefType<int32_t> descriptor = {rank, ptr}; 113 _mlir_ciface_printMemrefI32(&descriptor); 114 } 115 116 extern "C" void printMemrefI64(int64_t rank, void *ptr) { 117 UnrankedMemRefType<int64_t> descriptor = {rank, ptr}; 118 _mlir_ciface_printMemrefI64(&descriptor); 119 } 120 121 extern "C" void printMemrefF32(int64_t rank, void *ptr) { 122 UnrankedMemRefType<float> descriptor = {rank, ptr}; 123 _mlir_ciface_printMemrefF32(&descriptor); 124 } 125 126 extern "C" void printMemrefF64(int64_t rank, void *ptr) { 127 UnrankedMemRefType<double> descriptor = {rank, ptr}; 128 _mlir_ciface_printMemrefF64(&descriptor); 129 } 130 131 extern "C" void printCString(char *str) { printf("%s", str); } 132 133 extern "C" void _mlir_ciface_printMemref0dF32(StridedMemRefType<float, 0> *M) { 134 impl::printMemRef(*M); 135 } 136 extern "C" void _mlir_ciface_printMemref1dF32(StridedMemRefType<float, 1> *M) { 137 impl::printMemRef(*M); 138 } 139 extern "C" void _mlir_ciface_printMemref2dF32(StridedMemRefType<float, 2> *M) { 140 impl::printMemRef(*M); 141 } 142 extern "C" void _mlir_ciface_printMemref3dF32(StridedMemRefType<float, 3> *M) { 143 impl::printMemRef(*M); 144 } 145 extern "C" void _mlir_ciface_printMemref4dF32(StridedMemRefType<float, 4> *M) { 146 impl::printMemRef(*M); 147 } 148 149 extern "C" int64_t 150 _mlir_ciface_verifyMemRefI32(UnrankedMemRefType<int32_t> *actual, 151 UnrankedMemRefType<int32_t> *expected) { 152 return impl::verifyMemRef(*actual, *expected); 153 } 154 155 extern "C" int64_t 156 _mlir_ciface_verifyMemRefF32(UnrankedMemRefType<float> *actual, 157 UnrankedMemRefType<float> *expected) { 158 return impl::verifyMemRef(*actual, *expected); 159 } 160 161 extern "C" int64_t 162 _mlir_ciface_verifyMemRefF64(UnrankedMemRefType<double> *actual, 163 UnrankedMemRefType<double> *expected) { 164 return impl::verifyMemRef(*actual, *expected); 165 } 166 167 extern "C" int64_t verifyMemRefI32(int64_t rank, void *actualPtr, 168 void *expectedPtr) { 169 UnrankedMemRefType<int32_t> actualDesc = {rank, actualPtr}; 170 UnrankedMemRefType<int32_t> expectedDesc = {rank, expectedPtr}; 171 return _mlir_ciface_verifyMemRefI32(&actualDesc, &expectedDesc); 172 } 173 174 extern "C" int64_t verifyMemRefF32(int64_t rank, void *actualPtr, 175 void *expectedPtr) { 176 UnrankedMemRefType<float> actualDesc = {rank, actualPtr}; 177 UnrankedMemRefType<float> expectedDesc = {rank, expectedPtr}; 178 return _mlir_ciface_verifyMemRefF32(&actualDesc, &expectedDesc); 179 } 180 181 extern "C" int64_t verifyMemRefF64(int64_t rank, void *actualPtr, 182 void *expectedPtr) { 183 UnrankedMemRefType<double> actualDesc = {rank, actualPtr}; 184 UnrankedMemRefType<double> expectedDesc = {rank, expectedPtr}; 185 return _mlir_ciface_verifyMemRefF64(&actualDesc, &expectedDesc); 186 } 187 188 // NOLINTEND(*-identifier-naming) 189