liboffloadmic/runtime/offload_myo_target.cpp

   1 /*
   2     Copyright (c) 2014 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_register(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_fptr_table_register(
  72     FptrTableEntry *entry
  73 )
  74 {
  75     int entries = 0;
  76     FptrTableEntry *t_start;
  77
  78     OFFLOAD_DEBUG_TRACE(3, "%s(%p)\n", __func__, entry);
  79
  80     t_start = entry;
  81     while (t_start->funcName != 0) {
  82         OFFLOAD_DEBUG_TRACE_1(4, 0, c_offload_mic_myo_fptr,
  83                               "myo fptr entry name = \"%s\" addr = %p\n",
  84                               t_start->funcName, t_start->funcAddr);
  85         t_start++;
  86         entries++;
  87     }
  88
  89     if (entries > 0) {
  90         OFFLOAD_DEBUG_TRACE(3, "myoiTargetFptrTableRegister(%p, %d, 0)\n",
  91                             entry, entries);
  92         CheckResult("myoiTargetFptrTableRegister",
  93                     myoiTargetFptrTableRegister(entry, entries, 0));
  94     }
  95 }
  96
  97 extern "C" void __offload_myoAcquire(void)
  98 {
  99     OFFLOAD_DEBUG_TRACE(3, "%s\n", __func__);
 100     CheckResult("myoAcquire", myoAcquire());
 101 }
 102
 103 extern "C" void __offload_myoRelease(void)
 104 {
 105     OFFLOAD_DEBUG_TRACE(3, "%s\n", __func__);
 106     CheckResult("myoRelease", myoRelease());
 107 }
 108
 109 extern "C" void __intel_cilk_for_32_offload_wrapper(void *args_)
 110 {
 111     OFFLOAD_DEBUG_TRACE(3, "%s\n", __func__);
 112
 113     struct S {
 114         void *M1;
 115         unsigned int M2;
 116         unsigned int M3;
 117         char closure[];
 118     } *args = (struct S*) args_;
 119
 120     __cilkrts_cilk_for_32(args->M1, args->closure, args->M2, args->M3);
 121 }
 122
 123 extern "C" void __intel_cilk_for_64_offload_wrapper(void *args_)
 124 {
 125     OFFLOAD_DEBUG_TRACE(3, "%s\n", __func__);
 126
 127     struct S {
 128         void *M1;
 129         uint64_t M2;
 130         uint64_t M3;
 131         char closure[];
 132     } *args = (struct S*) args_;
 133
 134     __cilkrts_cilk_for_64(args->M1, args->closure, args->M2, args->M3);
 135 }
 136
 137 static void __offload_myo_once_init(void)
 138 {
 139     CheckResult("myoiRemoteFuncRegister",
 140                 myoiRemoteFuncRegister(
 141                     (MyoiRemoteFuncType) __intel_cilk_for_32_offload_wrapper,
 142                     "__intel_cilk_for_32_offload"));
 143     CheckResult("myoiRemoteFuncRegister",
 144                 myoiRemoteFuncRegister(
 145                     (MyoiRemoteFuncType) __intel_cilk_for_64_offload_wrapper,
 146                     "__intel_cilk_for_64_offload"));
 147 }
 148
 149 extern "C" void __offload_myoRegisterTables(
 150     SharedTableEntry *shared_table,
 151     FptrTableEntry *fptr_table
 152 )
 153 {
 154     OFFLOAD_DEBUG_TRACE(3, "%s\n", __func__);
 155
 156     // one time registration of Intel(R) Cilk(TM) language entries
 157     static pthread_once_t once_control = PTHREAD_ONCE_INIT;
 158     pthread_once(&once_control, __offload_myo_once_init);
 159
 160     // register module's tables
 161     if (shared_table->varName == 0 && fptr_table->funcName == 0) {
 162         return;
 163     }
 164
 165     __offload_myo_shared_table_register(shared_table);
 166     __offload_myo_fptr_table_register(fptr_table);
 167 }
 168
 169 extern "C" void* _Offload_shared_malloc(size_t size)
 170 {
 171     OFFLOAD_DEBUG_TRACE(3, "%s(%lld)\n", __func__, size);
 172     return myoSharedMalloc(size);
 173 }
 174
 175 extern "C" void _Offload_shared_free(void *ptr)
 176 {
 177     OFFLOAD_DEBUG_TRACE(3, "%s(%p)\n", __func__, ptr);
 178     myoSharedFree(ptr);
 179 }
 180
 181 extern "C" void* _Offload_shared_aligned_malloc(size_t size, size_t align)
 182 {
 183     OFFLOAD_DEBUG_TRACE(3, "%s(%lld, %lld)\n", __func__, size, align);
 184     return myoSharedAlignedMalloc(size, align);
 185 }
 186
 187 extern "C" void _Offload_shared_aligned_free(void *ptr)
 188 {
 189     OFFLOAD_DEBUG_TRACE(3, "%s(%p)\n", __func__, ptr);
 190     myoSharedAlignedFree(ptr);
 191 }
 192
 193 // temporary workaround for blocking behavior of myoiLibInit/Fini calls
 194 extern "C" void __offload_myoLibInit()
 195 {
 196     OFFLOAD_DEBUG_TRACE(3, "%s()\n", __func__);
 197     CheckResult("myoiLibInit", myoiLibInit(0, 0));
 198 }
 199
 200 extern "C" void __offload_myoLibFini()
 201 {
 202     OFFLOAD_DEBUG_TRACE(3, "%s()\n", __func__);
 203     myoiLibFini();
 204 }