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 // NOLINTBEGIN(*-identifier-naming) 20 21 extern "C" void 22 _mlir_ciface_print_memref_shape_i8(UnrankedMemRefType<int8_t> *M) { 23 std::cout << "Unranked Memref "; 24 printMemRefMetaData(std::cout, DynamicMemRefType<int8_t>(*M)); 25 std::cout << "\n"; 26 } 27 28 extern "C" void 29 _mlir_ciface_print_memref_shape_i32(UnrankedMemRefType<int32_t> *M) { 30 std::cout << "Unranked Memref "; 31 printMemRefMetaData(std::cout, DynamicMemRefType<int32_t>(*M)); 32 std::cout << "\n"; 33 } 34 35 extern "C" void 36 _mlir_ciface_print_memref_shape_i64(UnrankedMemRefType<int64_t> *M) { 37 std::cout << "Unranked Memref "; 38 printMemRefMetaData(std::cout, DynamicMemRefType<int64_t>(*M)); 39 std::cout << "\n"; 40 } 41 42 extern "C" void 43 _mlir_ciface_print_memref_shape_f32(UnrankedMemRefType<float> *M) { 44 std::cout << "Unranked Memref "; 45 printMemRefMetaData(std::cout, DynamicMemRefType<float>(*M)); 46 std::cout << "\n"; 47 } 48 49 extern "C" void 50 _mlir_ciface_print_memref_shape_f64(UnrankedMemRefType<double> *M) { 51 std::cout << "Unranked Memref "; 52 printMemRefMetaData(std::cout, DynamicMemRefType<double>(*M)); 53 std::cout << "\n"; 54 } 55 56 extern "C" void _mlir_ciface_print_memref_vector_4x4xf32( 57 StridedMemRefType<Vector2D<4, 4, float>, 2> *M) { 58 impl::printMemRef(*M); 59 } 60 61 extern "C" void _mlir_ciface_print_memref_i8(UnrankedMemRefType<int8_t> *M) { 62 impl::printMemRef(*M); 63 } 64 65 extern "C" void _mlir_ciface_print_memref_i32(UnrankedMemRefType<int32_t> *M) { 66 impl::printMemRef(*M); 67 } 68 69 extern "C" void _mlir_ciface_print_memref_i64(UnrankedMemRefType<int64_t> *M) { 70 impl::printMemRef(*M); 71 } 72 73 extern "C" void _mlir_ciface_print_memref_f32(UnrankedMemRefType<float> *M) { 74 impl::printMemRef(*M); 75 } 76 77 extern "C" void _mlir_ciface_print_memref_f64(UnrankedMemRefType<double> *M) { 78 impl::printMemRef(*M); 79 } 80 81 extern "C" int64_t _mlir_ciface_nano_time() { 82 auto now = std::chrono::high_resolution_clock::now(); 83 auto duration = now.time_since_epoch(); 84 auto nanoseconds = 85 std::chrono::duration_cast<std::chrono::nanoseconds>(duration); 86 return nanoseconds.count(); 87 } 88 89 extern "C" void print_memref_i32(int64_t rank, void *ptr) { 90 UnrankedMemRefType<int32_t> descriptor = {rank, ptr}; 91 _mlir_ciface_print_memref_i32(&descriptor); 92 } 93 94 extern "C" void print_memref_i64(int64_t rank, void *ptr) { 95 UnrankedMemRefType<int64_t> descriptor = {rank, ptr}; 96 _mlir_ciface_print_memref_i64(&descriptor); 97 } 98 99 extern "C" void print_memref_f32(int64_t rank, void *ptr) { 100 UnrankedMemRefType<float> descriptor = {rank, ptr}; 101 _mlir_ciface_print_memref_f32(&descriptor); 102 } 103 104 extern "C" void print_memref_f64(int64_t rank, void *ptr) { 105 UnrankedMemRefType<double> descriptor = {rank, ptr}; 106 _mlir_ciface_print_memref_f64(&descriptor); 107 } 108 109 extern "C" void 110 _mlir_ciface_print_memref_0d_f32(StridedMemRefType<float, 0> *M) { 111 impl::printMemRef(*M); 112 } 113 extern "C" void 114 _mlir_ciface_print_memref_1d_f32(StridedMemRefType<float, 1> *M) { 115 impl::printMemRef(*M); 116 } 117 extern "C" void 118 _mlir_ciface_print_memref_2d_f32(StridedMemRefType<float, 2> *M) { 119 impl::printMemRef(*M); 120 } 121 extern "C" void 122 _mlir_ciface_print_memref_3d_f32(StridedMemRefType<float, 3> *M) { 123 impl::printMemRef(*M); 124 } 125 extern "C" void 126 _mlir_ciface_print_memref_4d_f32(StridedMemRefType<float, 4> *M) { 127 impl::printMemRef(*M); 128 } 129 130 extern "C" int64_t 131 _mlir_ciface_verifyMemRefI32(UnrankedMemRefType<int32_t> *actual, 132 UnrankedMemRefType<int32_t> *expected) { 133 return impl::verifyMemRef(*actual, *expected); 134 } 135 136 extern "C" int64_t 137 _mlir_ciface_verifyMemRefF32(UnrankedMemRefType<float> *actual, 138 UnrankedMemRefType<float> *expected) { 139 return impl::verifyMemRef(*actual, *expected); 140 } 141 142 extern "C" int64_t 143 _mlir_ciface_verifyMemRefF64(UnrankedMemRefType<double> *actual, 144 UnrankedMemRefType<double> *expected) { 145 return impl::verifyMemRef(*actual, *expected); 146 } 147 148 extern "C" int64_t verifyMemRefI32(int64_t rank, void *actualPtr, 149 void *expectedPtr) { 150 UnrankedMemRefType<int32_t> actualDesc = {rank, actualPtr}; 151 UnrankedMemRefType<int32_t> expectedDesc = {rank, expectedPtr}; 152 return _mlir_ciface_verifyMemRefI32(&actualDesc, &expectedDesc); 153 } 154 155 extern "C" int64_t verifyMemRefF32(int64_t rank, void *actualPtr, 156 void *expectedPtr) { 157 UnrankedMemRefType<float> actualDesc = {rank, actualPtr}; 158 UnrankedMemRefType<float> expectedDesc = {rank, expectedPtr}; 159 return _mlir_ciface_verifyMemRefF32(&actualDesc, &expectedDesc); 160 } 161 162 extern "C" int64_t verifyMemRefF64(int64_t rank, void *actualPtr, 163 void *expectedPtr) { 164 UnrankedMemRefType<double> actualDesc = {rank, actualPtr}; 165 UnrankedMemRefType<double> expectedDesc = {rank, expectedPtr}; 166 return _mlir_ciface_verifyMemRefF64(&actualDesc, &expectedDesc); 167 } 168 169 // NOLINTEND(*-identifier-naming) 170