liboffloadmic/runtime/offload_myo_target.cpp

   1 /*
   2     Copyright (c) 2014-2015 Intel Corporation.  All Rights Reserved.
   3
   4     Redistribution and use in source and binary forms, with or without
   5     modification, are permitted provided that the following conditions
   6     are met:
   7
   8       * Redistributions of source code must retain the above copyright
   9         notice, this list of conditions and the following disclaimer.
  10       * Redistributions in binary form must reproduce the above copyright
  11         notice, this list of conditions and the following disclaimer in the
  12         documentation and/or other materials provided with the distribution.
  13       * Neither the name of Intel Corporation nor the names of its
  14         contributors may be used to endorse or promote products derived
  15         from this software without specific prior written permission.
  16
  17     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  18     "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  19     LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  20     A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  21     HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  22     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  23     LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  24     DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  25     THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  26     (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  27     OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  28 */
  29
  30
  31 #include "offload_myo_target.h"
  32 #include "offload_target.h"
  33
  34 extern "C" void __cilkrts_cilk_for_32(void*, void*, uint32_t, int32_t);
  35 extern "C" void __cilkrts_cilk_for_64(void*, void*, uint64_t, int32_t);
  36
  37 #pragma weak __cilkrts_cilk_for_32
  38 #pragma weak __cilkrts_cilk_for_64
  39
  40 static void CheckResult(const char *func, MyoError error) {
  41     if (error != MYO_SUCCESS) {
  42        LIBOFFLOAD_ERROR(c_myotarget_checkresult, func, error);
  43         exit(1);
  44     }
  45 }
  46
  47 static void __offload_myo_shared_table_process(SharedTableEntry *entry)
  48 {
  49     int entries = 0;
  50     SharedTableEntry *t_start;
  51
  52     OFFLOAD_DEBUG_TRACE(3, "%s(%p)\n", __func__, entry);
  53
  54     t_start = entry;
  55     while (t_start->varName != 0) {
  56         OFFLOAD_DEBUG_TRACE_1(4, 0, c_offload_mic_myo_shared,
  57                               "myo shared entry name = \"%s\" addr = %p\n",
  58                               t_start->varName, t_start->sharedAddr);
  59         t_start++;
  60         entries++;
  61     }
  62
  63     if (entries > 0) {
  64         OFFLOAD_DEBUG_TRACE(3, "myoiMicVarTableRegister(%p, %d)\n", entry,
  65                             entries);
  66         CheckResult("myoiMicVarTableRegister",
  67                     myoiMicVarTableRegister(entry, entries));
  68     }
  69 }
  70
  71 static void __offload_myo_shared_vtable_process(SharedTableEntry *entry)
  72 {
  73     int entries = 0;
  74     SharedTableEntry *t_start;
  75
  76     OFFLOAD_DEBUG_TRACE(3, "%s(%p)\n", __func__, entry);
  77
  78     t_start = entry;
  79     while (t_start->varName != 0) {
  80         OFFLOAD_DEBUG_TRACE_1(4, 0, c_offload_mic_myo_shared,
  81                               "myo shared vtable entry name"
  82                               " = \"%s\" addr = %p\n",
  83                               t_start->varName, t_start->sharedAddr);
  84         t_start++;
  85         entries++;
  86     }
  87
  88     if (entries > 0) {
  89         OFFLOAD_DEBUG_TRACE(3, "myoiMicVarTableRegister(%p, %d)\n", entry,
  90                             entries);
  91         CheckResult("myoiMicVarTableRegister",
  92                     myoiMicVarTableRegister(entry, entries));
  93     }
  94 }
  95
  96 static void __offload_myo_fptr_table_process(
  97     FptrTableEntry *entry
  98 )
  99 {
 100     int entries = 0;
 101     FptrTableEntry *t_start;
 102
 103     OFFLOAD_DEBUG_TRACE(3, "%s(%p)\n", __func__, entry);
 104
 105     t_start = entry;
 106     while (t_start->funcName != 0) {
 107         OFFLOAD_DEBUG_TRACE_1(4, 0, c_offload_mic_myo_fptr,
 108                               "myo fptr entry name = \"%s\" addr = %p\n",
 109                               t_start->funcName, t_start->funcAddr);
 110         t_start++;
 111         entries++;
 112     }
 113
 114     if (entries > 0) {
 115         OFFLOAD_DEBUG_TRACE(3, "myoiTargetFptrTableRegister(%p, %d, 0)\n",
 116                             entry, entries);
 117         CheckResult("myoiTargetFptrTableRegister",
 118                     myoiTargetFptrTableRegister(entry, entries, 0));
 119     }
 120 }
 121
 122 void __offload_myo_shared_init_table_process(InitTableEntry* entry)
 123 {
 124     OFFLOAD_DEBUG_TRACE(3, "%s(%p)\n", __func__, entry);
 125
 126     for (; entry->func != 0; entry++) {
 127         // Invoke the function to init the shared memory
 128         OFFLOAD_DEBUG_TRACE(3, "Invoked a shared init function @%p\n",
 129             (void *)(entry->func));
 130         entry->func();
 131     }
 132 }
 133
 134 extern "C" void __offload_myoAcquire(void)
 135 {
 136     OFFLOAD_DEBUG_TRACE(3, "%s\n", __func__);
 137
 138     CheckResult("myoAcquire", myoAcquire());
 139 }
 140
 141 extern "C" void __offload_myoRelease(void)
 142 {
 143     OFFLOAD_DEBUG_TRACE(3, "%s\n", __func__);
 144     CheckResult("myoRelease", myoRelease());
 145 }
 146
 147 extern "C" void __intel_cilk_for_32_offload_wrapper(void *args_)
 148 {
 149     OFFLOAD_DEBUG_TRACE(3, "%s\n", __func__);
 150
 151     struct S {
 152         void *M1;
 153         unsigned int M2;
 154         unsigned int M3;
 155         char closure[];
 156     } *args = (struct S*) args_;
 157
 158     __cilkrts_cilk_for_32(args->M1, args->closure, args->M2, args->M3);
 159 }
 160
 161 extern "C" void __intel_cilk_for_64_offload_wrapper(void *args_)
 162 {
 163     OFFLOAD_DEBUG_TRACE(3, "%s\n", __func__);
 164
 165     struct S {
 166         void *M1;
 167         uint64_t M2;
 168         uint64_t M3;
 169         char closure[];
 170     } *args = (struct S*) args_;
 171
 172     __cilkrts_cilk_for_64(args->M1, args->closure, args->M2, args->M3);
 173 }
 174
 175 static void __offload_myo_once_init(void)
 176 {
 177     CheckResult("myoiRemoteFuncRegister",
 178                 myoiRemoteFuncRegister(
 179                     (MyoiRemoteFuncType) __intel_cilk_for_32_offload_wrapper,
 180                     "__intel_cilk_for_32_offload"));
 181     CheckResult("myoiRemoteFuncRegister",
 182                 myoiRemoteFuncRegister(
 183                     (MyoiRemoteFuncType) __intel_cilk_for_64_offload_wrapper,
 184                     "__intel_cilk_for_64_offload"));
 185 }
 186
 187 extern "C" void __offload_myoRegisterTables(
 188     SharedTableEntry *shared_table,
 189     FptrTableEntry *fptr_table
 190 )
 191 {
 192     OFFLOAD_DEBUG_TRACE(3, "%s\n", __func__);
 193
 194     // one time registration of Intel(R) Cilk(TM) language entries
 195     static pthread_once_t once_control = PTHREAD_ONCE_INIT;
 196     pthread_once(&once_control, __offload_myo_once_init);
 197
 198     // register module's tables
 199     if (shared_table->varName == 0 && fptr_table->funcName == 0) {
 200         return;
 201     }
 202
 203     __offload_myo_shared_table_process(shared_table);
 204     __offload_myo_fptr_table_process(fptr_table);
 205 }
 206
 207 extern "C" void __offload_myoProcessTables(
 208     InitTableEntry* init_table,
 209     SharedTableEntry *shared_table,
 210     SharedTableEntry *shared_vtable,
 211     FptrTableEntry *fptr_table
 212 )
 213 {
 214     OFFLOAD_DEBUG_TRACE(3, "%s\n", __func__);
 215
 216     // one time registration of Intel(R) Cilk(TM) language entries
 217     static pthread_once_t once_control = PTHREAD_ONCE_INIT;
 218     pthread_once(&once_control, __offload_myo_once_init);
 219
 220     // register module's tables
 221     // check slot-1 of the function table because
 222     // slot-0 is predefined with --vtable_initializer--
 223     if (shared_table->varName == 0 &&
 224         shared_vtable->varName == 0 &&
 225         fptr_table[1].funcName == 0) {
 226         return;
 227     }
 228
 229     __offload_myo_shared_table_process(shared_table);
 230     __offload_myo_shared_vtable_process(shared_vtable);
 231     __offload_myo_fptr_table_process(fptr_table);
 232 }
 233
 234 extern "C" void* _Offload_shared_malloc(size_t size)
 235 {
 236     OFFLOAD_DEBUG_TRACE(3, "%s(%lld)\n", __func__, size);
 237     return myoSharedMalloc(size);
 238 }
 239
 240 extern "C" void _Offload_shared_free(void *ptr)
 241 {
 242     OFFLOAD_DEBUG_TRACE(3, "%s(%p)\n", __func__, ptr);
 243     myoSharedFree(ptr);
 244 }
 245
 246 extern "C" void* _Offload_shared_aligned_malloc(size_t size, size_t align)
 247 {
 248     OFFLOAD_DEBUG_TRACE(3, "%s(%lld, %lld)\n", __func__, size, align);
 249     return myoSharedAlignedMalloc(size, align);
 250 }
 251
 252 extern "C" void _Offload_shared_aligned_free(void *ptr)
 253 {
 254     OFFLOAD_DEBUG_TRACE(3, "%s(%p)\n", __func__, ptr);
 255     myoSharedAlignedFree(ptr);
 256 }
 257
 258 extern "C" void* _Offload_shared_aligned_arena_malloc(
 259     MyoArena arena,
 260     size_t size,
 261     size_t align
 262 )
 263 {
 264     OFFLOAD_DEBUG_TRACE(
 265         3, "%s(%u, %lld, %lld)\n", __func__, arena, size, align);
 266
 267     return myoArenaAlignedMalloc(arena, size, align);
 268 }
 269
 270 extern "C" void _Offload_shared_aligned_arena_free(
 271     MyoArena arena,
 272     void *ptr
 273 )
 274 {
 275     OFFLOAD_DEBUG_TRACE(3, "%s(%u, %p)\n", __func__, arena, ptr);
 276
 277     myoArenaAlignedFree(arena, ptr);
 278 }
 279
 280 extern "C" void _Offload_shared_arena_acquire(
 281     MyoArena arena
 282 )
 283 {
 284     OFFLOAD_DEBUG_TRACE(3, "%s(%u)\n", __func__, arena);
 285
 286     myoArenaAcquire(arena);
 287 }
 288
 289 extern "C" void _Offload_shared_arena_release(
 290     MyoArena arena
 291 )
 292 {
 293     OFFLOAD_DEBUG_TRACE(3, "%s(%u)\n", __func__, arena);
 294
 295     myoArenaRelease(arena);
 296 }
 297
 298 // temporary workaround for blocking behavior of myoiLibInit/Fini calls
 299 extern "C" void __offload_myoLibInit()
 300 {
 301     OFFLOAD_DEBUG_TRACE(3, "%s()\n", __func__);
 302     CheckResult("myoiLibInit", myoiLibInit(0, 0));
 303 }
 304
 305 extern "C" void __offload_myoLibFini()
 306 {
 307     OFFLOAD_DEBUG_TRACE(3, "%s()\n", __func__);
 308     myoiLibFini();
 309 }