1635 lines
44 KiB
C++
1635 lines
44 KiB
C++
/*
|
|
Copyright (c) 2014-2016 Intel Corporation. All Rights Reserved.
|
|
|
|
Redistribution and use in source and binary forms, with or without
|
|
modification, are permitted provided that the following conditions
|
|
are met:
|
|
|
|
* Redistributions of source code must retain the above copyright
|
|
notice, this list of conditions and the following disclaimer.
|
|
* Redistributions in binary form must reproduce the above copyright
|
|
notice, this list of conditions and the following disclaimer in the
|
|
documentation and/or other materials provided with the distribution.
|
|
* Neither the name of Intel Corporation nor the names of its
|
|
contributors may be used to endorse or promote products derived
|
|
from this software without specific prior written permission.
|
|
|
|
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
|
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
|
HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
|
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*/
|
|
|
|
#include <set>
|
|
#include <map>
|
|
#include <queue>
|
|
|
|
#include "coi_host.h"
|
|
|
|
#include "coi_version_asm.h"
|
|
|
|
#define CYCLE_FREQUENCY 1000000000
|
|
|
|
enum buffer_t
|
|
{
|
|
BUFFER_NORMAL,
|
|
BUFFER_MEMORY
|
|
};
|
|
|
|
struct Engine
|
|
{
|
|
COI_ISA_TYPE type;
|
|
uint32_t index;
|
|
char *dir;
|
|
};
|
|
|
|
struct Function
|
|
{
|
|
void *ptr;
|
|
uint32_t num_buffers;
|
|
uint64_t *bufs_size;
|
|
void * *bufs_data_target;
|
|
uint16_t misc_data_len;
|
|
void *misc_data;
|
|
uint16_t return_value_len;
|
|
void *return_value;
|
|
COIEVENT completion_event;
|
|
};
|
|
|
|
struct Callback
|
|
{
|
|
COI_EVENT_CALLBACK ptr;
|
|
const void *data;
|
|
};
|
|
|
|
struct Process
|
|
{
|
|
pid_t pid;
|
|
int pipe_host2tgt;
|
|
int pipe_tgt2host;
|
|
Engine *engine;
|
|
void **functions;
|
|
};
|
|
|
|
struct Pipeline
|
|
{
|
|
pthread_t thread;
|
|
bool destroy;
|
|
bool is_destroyed;
|
|
char *pipe_host2tgt_path;
|
|
char *pipe_tgt2host_path;
|
|
int pipe_host2tgt;
|
|
int pipe_tgt2host;
|
|
std::queue<Function> queue;
|
|
Process *process;
|
|
};
|
|
|
|
struct Buffer
|
|
{
|
|
buffer_t type;
|
|
char *name;
|
|
int fd;
|
|
int fd_target;
|
|
uint64_t size;
|
|
void *data;
|
|
void *data_target;
|
|
Process *process;
|
|
};
|
|
|
|
|
|
/* Environment variables. */
|
|
extern char **environ;
|
|
|
|
/* List of directories for removing on exit. */
|
|
static char **tmp_dirs;
|
|
static unsigned tmp_dirs_num;
|
|
|
|
/* Number of emulated MIC engines. */
|
|
static long num_engines;
|
|
|
|
/* Number of the last COI pipeline. */
|
|
static uint32_t max_pipeline_num;
|
|
|
|
/* Set of undestroyed pipelines. */
|
|
static std::set<Pipeline *> pipelines;
|
|
|
|
/* Number of the last COI event, the event #0 is always signalled. */
|
|
static uint64_t max_event_num = 1;
|
|
|
|
/* Set of created COI events, which are not signalled. */
|
|
static std::set<uint64_t> non_signalled_events;
|
|
|
|
/* Set of COI events, which encountered errors. */
|
|
static std::map<uint64_t, COIRESULT> errored_events;
|
|
|
|
/* Set of registered callbacks, indexed by event number. */
|
|
static std::map<uint64_t, Callback> callbacks;
|
|
|
|
/* Mutex to sync parallel execution. */
|
|
static pthread_mutex_t mutex = PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP;
|
|
|
|
|
|
static COIRESULT
|
|
read_long_env (const char *env_name, long *var, long var_default)
|
|
{
|
|
char *str = getenv (env_name);
|
|
char *s;
|
|
|
|
if (!str || *str == '\0')
|
|
*var = var_default;
|
|
else
|
|
{
|
|
errno = 0;
|
|
*var = strtol (str, &s, 0);
|
|
if (errno != 0 || s == str || *s != '\0')
|
|
COIERROR ("Variable %s has invalid value.", env_name);
|
|
}
|
|
|
|
return COI_SUCCESS;
|
|
}
|
|
|
|
__attribute__((constructor))
|
|
static void
|
|
init ()
|
|
{
|
|
if (read_long_env (OFFLOAD_EMUL_NUM_ENV, &num_engines, 1) == COI_ERROR)
|
|
exit (0);
|
|
}
|
|
|
|
|
|
/* Helper function for directory removing. */
|
|
static COIRESULT remove_directory (char *path)
|
|
{
|
|
char *file;
|
|
struct dirent *entry;
|
|
struct stat statfile;
|
|
DIR *dir = opendir (path);
|
|
if (dir == NULL)
|
|
COIERROR ("Cannot open directory %s.", dir);
|
|
|
|
while (entry = readdir (dir))
|
|
{
|
|
if (!strcmp (entry->d_name, ".") || !strcmp (entry->d_name, ".."))
|
|
continue;
|
|
|
|
MALLOC (char *, file, strlen (path) + strlen (entry->d_name) + 2);
|
|
sprintf (file, "%s/%s", path, entry->d_name);
|
|
|
|
if (stat (file, &statfile) < 0)
|
|
COIERROR ("Cannot retrieve information about file %s.", file);
|
|
|
|
if (S_ISDIR (statfile.st_mode))
|
|
{
|
|
if (remove_directory (file) == COI_ERROR)
|
|
return COI_ERROR;
|
|
}
|
|
else
|
|
{
|
|
if (unlink (file) < 0)
|
|
COIERROR ("Cannot unlink file %s.", file);
|
|
}
|
|
|
|
free (file);
|
|
}
|
|
|
|
if (closedir (dir) < 0)
|
|
COIERROR ("Cannot close directory %s.", path);
|
|
if (rmdir (path) < 0)
|
|
COIERROR ("Cannot remove directory %s.", path);
|
|
|
|
return COI_SUCCESS;
|
|
}
|
|
|
|
__attribute__((destructor))
|
|
static void
|
|
cleanup ()
|
|
{
|
|
for (unsigned i = 0; i < tmp_dirs_num; i++)
|
|
{
|
|
remove_directory (tmp_dirs[i]);
|
|
free (tmp_dirs[i]);
|
|
}
|
|
free (tmp_dirs);
|
|
}
|
|
|
|
static COIRESULT
|
|
start_critical_section ()
|
|
{
|
|
if (pthread_mutex_lock (&mutex) != 0)
|
|
COIERROR ("Cannot lock mutex.");
|
|
return COI_SUCCESS;
|
|
}
|
|
|
|
static COIRESULT
|
|
finish_critical_section ()
|
|
{
|
|
if (pthread_mutex_unlock (&mutex) != 0)
|
|
COIERROR ("Cannot unlock mutex.");
|
|
return COI_SUCCESS;
|
|
}
|
|
|
|
static bool
|
|
pipeline_is_destroyed (const Pipeline *pipeline)
|
|
{
|
|
start_critical_section ();
|
|
bool res = pipeline->is_destroyed;
|
|
finish_critical_section ();
|
|
return res;
|
|
}
|
|
|
|
static void
|
|
maybe_invoke_callback (const COIEVENT event, const COIRESULT result)
|
|
{
|
|
std::map<uint64_t, Callback>::iterator cb = callbacks.find (event.opaque[0]);
|
|
|
|
if (cb != callbacks.end ())
|
|
{
|
|
Callback callback = cb->second;
|
|
callback.ptr (event, result, callback.data);
|
|
callbacks.erase (cb);
|
|
}
|
|
}
|
|
|
|
static void
|
|
signal_event (const COIEVENT event, const COIRESULT result)
|
|
{
|
|
if (result != COI_SUCCESS)
|
|
errored_events.insert (std::pair <uint64_t, COIRESULT> (event.opaque[0],
|
|
result));
|
|
non_signalled_events.erase (event.opaque[0]);
|
|
|
|
maybe_invoke_callback (event, result);
|
|
}
|
|
|
|
static COIRESULT
|
|
get_event_result (const COIEVENT event)
|
|
{
|
|
COIRESULT res = COI_SUCCESS;
|
|
|
|
std::map<uint64_t, COIRESULT>::iterator ee
|
|
= errored_events.find (event.opaque[0]);
|
|
|
|
if (ee != errored_events.end ())
|
|
res = ee->second;
|
|
|
|
return res;
|
|
}
|
|
|
|
|
|
extern "C"
|
|
{
|
|
|
|
COIRESULT
|
|
SYMBOL_VERSION (COIBufferCopy, 1) (COIBUFFER in_DestBuffer,
|
|
COIBUFFER in_SourceBuffer,
|
|
uint64_t in_DestOffset,
|
|
uint64_t in_SourceOffset,
|
|
uint64_t in_Length,
|
|
COI_COPY_TYPE in_Type,
|
|
uint32_t in_NumDependencies,
|
|
const COIEVENT *in_pDependencies, // Ignored
|
|
COIEVENT *out_pCompletion)
|
|
{
|
|
COITRACE ("COIBufferCopy");
|
|
|
|
/* Features of liboffloadmic. */
|
|
assert (in_DestBuffer != NULL);
|
|
assert (in_SourceBuffer != NULL);
|
|
assert (in_Type == COI_COPY_UNSPECIFIED);
|
|
assert (in_NumDependencies == 0);
|
|
|
|
/* Convert input arguments. */
|
|
Buffer *dest = (Buffer *) in_DestBuffer;
|
|
Buffer *source = (Buffer *) in_SourceBuffer;
|
|
|
|
start_critical_section ();
|
|
|
|
/* Map buffers if needed. */
|
|
if (dest->data == 0 && dest->type == BUFFER_NORMAL)
|
|
if (COIBufferMap (in_DestBuffer, 0, dest->size, (COI_MAP_TYPE) 0,
|
|
0, 0, 0, 0, 0) == COI_ERROR)
|
|
return COI_ERROR;
|
|
if (source->data == 0 && source->type == BUFFER_NORMAL)
|
|
if (COIBufferMap (in_SourceBuffer, 0, source->size, (COI_MAP_TYPE) 0,
|
|
0, 0, 0, 0, 0) == COI_ERROR)
|
|
return COI_ERROR;
|
|
|
|
/* Copy data. */
|
|
if (source->data != 0 && dest->data != 0)
|
|
memcpy ((void *) ((uintptr_t) dest->data + in_DestOffset),
|
|
(void *) ((uintptr_t) source->data + in_SourceOffset), in_Length);
|
|
else
|
|
{
|
|
assert (dest->process == source->process);
|
|
|
|
Buffer *buffer;
|
|
cmd_t cmd = CMD_BUFFER_COPY;
|
|
|
|
/* Create intermediary buffer. */
|
|
if (COIBufferCreate (in_Length, COI_BUFFER_NORMAL, 0, 0, 1,
|
|
(COIPROCESS*) &dest->process,
|
|
(COIBUFFER *) &buffer) == COI_ERROR)
|
|
return COI_ERROR;
|
|
|
|
int pipe_host2tgt = dest->process->pipe_host2tgt;
|
|
int pipe_tgt2host = dest->process->pipe_tgt2host;
|
|
|
|
/* Copy from source to intermediary buffer. */
|
|
if (source->data == 0)
|
|
{
|
|
assert (source->data_target != 0);
|
|
|
|
/* Send data to target. */
|
|
WRITE (pipe_host2tgt, &cmd, sizeof (cmd_t));
|
|
WRITE (pipe_host2tgt, &buffer->data_target, sizeof (void *));
|
|
WRITE (pipe_host2tgt, &source->data_target, sizeof (void *));
|
|
WRITE (pipe_host2tgt, &buffer->size, sizeof (uint64_t));
|
|
|
|
/* Receive data from target. */
|
|
READ (pipe_tgt2host, &cmd, sizeof (cmd_t));
|
|
}
|
|
else
|
|
{
|
|
if (COIBufferCopy ((COIBUFFER) buffer, in_SourceBuffer, 0,
|
|
in_SourceOffset, in_Length, in_Type, 0, 0, 0)
|
|
== COI_ERROR)
|
|
return COI_ERROR;
|
|
}
|
|
|
|
/* Copy from intermediary buffer to dest. */
|
|
if (dest->data == 0)
|
|
{
|
|
assert (dest->data_target != 0);
|
|
|
|
/* Send data to target. */
|
|
WRITE (pipe_host2tgt, &cmd, sizeof (cmd_t));
|
|
WRITE (pipe_host2tgt, &dest->data_target, sizeof (void *));
|
|
WRITE (pipe_host2tgt, &buffer->data_target, sizeof (void *));
|
|
WRITE (pipe_host2tgt, &buffer->size, sizeof (uint64_t));
|
|
|
|
/* Receive data from target. */
|
|
READ (pipe_tgt2host, &cmd, sizeof (cmd_t));
|
|
}
|
|
else
|
|
{
|
|
if (COIBufferCopy (in_DestBuffer, (COIBUFFER) buffer, in_DestOffset,
|
|
0, in_Length, in_Type, 0, 0, 0) == COI_ERROR)
|
|
return COI_ERROR;
|
|
}
|
|
|
|
/* Unmap on target and destroy intermediary buffer. */
|
|
if (COIBufferDestroy ((COIBUFFER) buffer) == COI_ERROR)
|
|
return COI_ERROR;
|
|
}
|
|
|
|
/* Unmap buffers if needed. */
|
|
if (dest->type == BUFFER_NORMAL)
|
|
if (COIBufferUnmap ((COIMAPINSTANCE) dest, 0, 0, 0) == COI_ERROR)
|
|
return COI_ERROR;
|
|
if (source->type == BUFFER_NORMAL)
|
|
if (COIBufferUnmap ((COIMAPINSTANCE) source, 0, 0, 0) == COI_ERROR)
|
|
return COI_ERROR;
|
|
|
|
finish_critical_section ();
|
|
|
|
if (out_pCompletion)
|
|
out_pCompletion->opaque[0] = 0;
|
|
|
|
return COI_SUCCESS;
|
|
}
|
|
|
|
|
|
COIRESULT
|
|
SYMBOL_VERSION (COIBufferCreate, 1) (uint64_t in_Size,
|
|
COI_BUFFER_TYPE in_Type,
|
|
uint32_t in_Flags,
|
|
const void *in_pInitData,
|
|
uint32_t in_NumProcesses,
|
|
const COIPROCESS *in_pProcesses,
|
|
COIBUFFER *out_pBuffer)
|
|
{
|
|
COITRACE ("COIBufferCreate");
|
|
|
|
char *shm_name;
|
|
int shm_fd;
|
|
const int ullong_max_len = 20;
|
|
|
|
/* Features of liboffloadmic. */
|
|
assert (in_Type == COI_BUFFER_NORMAL || in_Type == COI_BUFFER_OPENCL);
|
|
assert ((in_Flags & COI_SINK_MEMORY) == 0);
|
|
assert ((in_Flags & COI_SAME_ADDRESS_SINKS) == 0);
|
|
assert ((in_Flags & COI_SAME_ADDRESS_SINKS_AND_SOURCE) == 0);
|
|
assert (in_pInitData == NULL);
|
|
assert (in_NumProcesses == 1);
|
|
assert (in_pProcesses != NULL);
|
|
assert (out_pBuffer != NULL);
|
|
|
|
/* Create shared memory with an unique name. */
|
|
MALLOC (char *, shm_name, strlen (SHM_NAME) + ullong_max_len + 1);
|
|
for (unsigned long long i = 0; i >= 0; i++)
|
|
{
|
|
sprintf (shm_name, SHM_NAME "%lu", i);
|
|
shm_fd = shm_open (shm_name, O_CLOEXEC | O_CREAT | O_EXCL | O_RDWR,
|
|
S_IRUSR | S_IWUSR);
|
|
if (shm_fd > 0)
|
|
break;
|
|
}
|
|
if (ftruncate (shm_fd, in_Size) < 0)
|
|
COIERROR ("Cannot truncate shared memory file.");
|
|
|
|
/* Create buffer. */
|
|
Buffer *buf = new Buffer;
|
|
buf->data = 0;
|
|
buf->fd = shm_fd;
|
|
buf->process = (Process *) in_pProcesses[0];
|
|
buf->size = in_Size;
|
|
buf->type = BUFFER_NORMAL;
|
|
STRDUP (buf->name, shm_name);
|
|
|
|
/* Map buffer on target. */
|
|
size_t len = strlen (buf->name) + 1;
|
|
|
|
start_critical_section ();
|
|
|
|
/* Send data to target. */
|
|
const cmd_t cmd = CMD_BUFFER_MAP;
|
|
int pipe_host2tgt = buf->process->pipe_host2tgt;
|
|
WRITE (pipe_host2tgt, &cmd, sizeof (cmd_t));
|
|
WRITE (pipe_host2tgt, &len, sizeof (size_t));
|
|
WRITE (pipe_host2tgt, buf->name, len);
|
|
WRITE (pipe_host2tgt, &buf->size, sizeof (uint64_t));
|
|
|
|
/* Receive data from target. */
|
|
int pipe_tgt2host = buf->process->pipe_tgt2host;
|
|
READ (pipe_tgt2host, &buf->fd_target, sizeof (int));
|
|
READ (pipe_tgt2host, &buf->data_target, sizeof (void *));
|
|
|
|
finish_critical_section ();
|
|
|
|
/* Prepare output arguments. */
|
|
*out_pBuffer = (COIBUFFER) buf;
|
|
|
|
/* Clean up. */
|
|
free (shm_name);
|
|
|
|
return COI_SUCCESS;
|
|
}
|
|
|
|
|
|
COIRESULT
|
|
SYMBOL_VERSION (COIBufferCreateFromMemory, 1) (uint64_t in_Size,
|
|
COI_BUFFER_TYPE in_Type,
|
|
uint32_t in_Flags,
|
|
void *in_Memory,
|
|
uint32_t in_NumProcesses,
|
|
const COIPROCESS *in_pProcesses,
|
|
COIBUFFER *out_pBuffer)
|
|
{
|
|
COITRACE ("COIBufferCreateFromMemory");
|
|
|
|
/* Features of liboffloadmic. */
|
|
assert (in_Type == COI_BUFFER_NORMAL);
|
|
assert ((in_Flags & COI_SAME_ADDRESS_SINKS) == 0);
|
|
assert ((in_Flags & COI_SAME_ADDRESS_SINKS_AND_SOURCE) == 0);
|
|
assert (in_NumProcesses == 1);
|
|
assert (in_pProcesses != NULL);
|
|
assert (out_pBuffer != NULL);
|
|
|
|
/* Create buffer. */
|
|
Buffer *buf = new Buffer;
|
|
buf->data = (in_Flags & COI_SINK_MEMORY) == 0 ? in_Memory : 0;
|
|
buf->data_target = (in_Flags & COI_SINK_MEMORY) != 0 ? in_Memory : 0;
|
|
buf->process = (Process *) in_pProcesses[0];
|
|
buf->size = in_Size;
|
|
buf->type = BUFFER_MEMORY;
|
|
|
|
/* Prepare output argument. */
|
|
*out_pBuffer = (COIBUFFER) buf;
|
|
|
|
return COI_SUCCESS;
|
|
}
|
|
|
|
|
|
COIRESULT
|
|
SYMBOL_VERSION (COIBufferDestroy, 1) (COIBUFFER in_Buffer)
|
|
{
|
|
COITRACE ("COIBufferDestroy");
|
|
|
|
cmd_t cmd = CMD_BUFFER_UNMAP;
|
|
|
|
assert (in_Buffer != NULL);
|
|
|
|
/* Convert input arguments. */
|
|
Buffer *buf = (Buffer *) in_Buffer;
|
|
|
|
/* Unmap buffer on host. */
|
|
if (buf->data != 0 && buf->type == BUFFER_NORMAL)
|
|
if (COIBufferUnmap ((COIMAPINSTANCE) in_Buffer, 0, 0, 0) == COI_ERROR)
|
|
return COI_ERROR;
|
|
|
|
/* Unmap buffer on target. */
|
|
if (buf->data_target != 0)
|
|
{
|
|
start_critical_section ();
|
|
|
|
/* Send data to target. */
|
|
int pipe_host2tgt = buf->process->pipe_host2tgt;
|
|
WRITE (pipe_host2tgt, &cmd, sizeof (cmd_t));
|
|
WRITE (pipe_host2tgt, &buf->fd_target, sizeof (int));
|
|
WRITE (pipe_host2tgt, &buf->data_target, sizeof (void *));
|
|
WRITE (pipe_host2tgt, &buf->size, sizeof (uint64_t));
|
|
|
|
/* Receive data from target. */
|
|
READ (buf->process->pipe_tgt2host, &cmd, sizeof (cmd_t));
|
|
|
|
finish_critical_section ();
|
|
}
|
|
|
|
/* Unlink shared memory. */
|
|
if (buf->type == BUFFER_NORMAL)
|
|
{
|
|
if (close (buf->fd) < 0)
|
|
COIERROR ("Cannot close shared memory file.");
|
|
if (shm_unlink (buf->name) < 0)
|
|
COIERROR ("Cannot unlink shared memory.");
|
|
free (buf->name);
|
|
}
|
|
|
|
/* Clean up. */
|
|
delete buf;
|
|
|
|
return COI_SUCCESS;
|
|
}
|
|
|
|
|
|
COIRESULT
|
|
SYMBOL_VERSION (COIBufferGetSinkAddress, 1) (COIBUFFER in_Buffer,
|
|
uint64_t *out_pAddress)
|
|
{
|
|
COITRACE ("COIBufferGetSinkAddress");
|
|
|
|
assert (in_Buffer != NULL);
|
|
assert (out_pAddress != NULL);
|
|
|
|
/* Convert input arguments. */
|
|
Buffer *buf = (Buffer *) in_Buffer;
|
|
|
|
/* Here should come BUFFER_NORMAL buffer. */
|
|
assert (buf->type == BUFFER_NORMAL);
|
|
|
|
/* Prepare output argument. */
|
|
*out_pAddress = (uint64_t) buf->data_target;
|
|
|
|
return COI_SUCCESS;
|
|
}
|
|
|
|
|
|
COIRESULT
|
|
SYMBOL_VERSION (COIBufferMap, 1) (COIBUFFER in_Buffer,
|
|
uint64_t in_Offset,
|
|
uint64_t in_Length, // Ignored
|
|
COI_MAP_TYPE in_Type, // Ignored
|
|
uint32_t in_NumDependencies,
|
|
const COIEVENT *in_pDependencies, // Ignored
|
|
COIEVENT *out_pCompletion,
|
|
COIMAPINSTANCE *out_pMapInstance,
|
|
void **out_ppData)
|
|
{
|
|
COITRACE ("COIBufferMap");
|
|
|
|
/* Features of liboffloadmic. */
|
|
assert (in_Offset == 0);
|
|
assert (in_NumDependencies == 0);
|
|
|
|
/* Convert input arguments. */
|
|
Buffer *buf = (Buffer *) in_Buffer;
|
|
|
|
/* Only BUFFER_NORMAL buffers should come here. */
|
|
assert (buf->type == BUFFER_NORMAL);
|
|
|
|
/* Map shared memory. */
|
|
buf->data = mmap (NULL, buf->size, PROT_READ | PROT_WRITE,
|
|
MAP_SHARED, buf->fd, 0);
|
|
if (buf->data == NULL)
|
|
COIERROR ("Cannot map shared memory.");
|
|
|
|
/* Prepare output arguments. */
|
|
if (out_pMapInstance != 0)
|
|
*out_pMapInstance = (COIMAPINSTANCE) buf;
|
|
if (out_ppData != 0)
|
|
*out_ppData = buf->data;
|
|
|
|
if (out_pCompletion)
|
|
out_pCompletion->opaque[0] = 0;
|
|
|
|
return COI_SUCCESS;
|
|
}
|
|
|
|
|
|
COIRESULT
|
|
SYMBOL_VERSION (COIBufferRead, 1) (COIBUFFER in_SourceBuffer,
|
|
uint64_t in_Offset,
|
|
void *in_pDestData,
|
|
uint64_t in_Length,
|
|
COI_COPY_TYPE in_Type,
|
|
uint32_t in_NumDependencies,
|
|
const COIEVENT *in_pDependencies, // Ignored
|
|
COIEVENT *out_pCompletion)
|
|
{
|
|
COITRACE ("COIBufferRead");
|
|
|
|
/* Features of liboffloadmic. */
|
|
assert (in_pDestData != NULL);
|
|
assert (in_Type == COI_COPY_UNSPECIFIED);
|
|
assert (in_NumDependencies == 0);
|
|
|
|
/* Convert input arguments. */
|
|
Buffer *buf = (Buffer *) in_SourceBuffer;
|
|
|
|
start_critical_section ();
|
|
|
|
/* Map buffers if needed. */
|
|
if (buf->data == 0 && buf->type == BUFFER_NORMAL)
|
|
if (COIBufferMap (in_SourceBuffer, 0, buf->size, (COI_MAP_TYPE) 0, 0, 0, 0,
|
|
0, 0) == COI_ERROR)
|
|
return COI_ERROR;
|
|
|
|
/* Copy data. */
|
|
memcpy (in_pDestData, (void *) ((uintptr_t) buf->data + in_Offset),
|
|
in_Length);
|
|
|
|
/* Unmap buffers if needed. */
|
|
if (buf->type == BUFFER_NORMAL)
|
|
if (COIBufferUnmap ((COIMAPINSTANCE) buf, 0, 0, 0) == COI_ERROR)
|
|
return COI_ERROR;
|
|
|
|
finish_critical_section ();
|
|
|
|
if (out_pCompletion)
|
|
out_pCompletion->opaque[0] = 0;
|
|
|
|
return COI_SUCCESS;
|
|
}
|
|
|
|
|
|
COIRESULT
|
|
SYMBOL_VERSION (COIBufferSetState, 1) (COIBUFFER in_Buffer, // Ignored
|
|
COIPROCESS in_Process, // Ignored
|
|
COI_BUFFER_STATE in_State, // Ignored
|
|
COI_BUFFER_MOVE_FLAG in_DataMove,
|
|
uint32_t in_NumDependencies,
|
|
const COIEVENT *in_pDependencies, // Ignored
|
|
COIEVENT *out_pCompletion)
|
|
{
|
|
COITRACE ("COIBufferSetState");
|
|
|
|
/* Features of liboffloadmic. */
|
|
assert (in_DataMove == COI_BUFFER_NO_MOVE);
|
|
assert (in_NumDependencies == 0);
|
|
|
|
/* Looks like we have nothing to do here. */
|
|
|
|
if (out_pCompletion)
|
|
out_pCompletion->opaque[0] = 0;
|
|
|
|
return COI_SUCCESS;
|
|
}
|
|
|
|
|
|
COIRESULT
|
|
SYMBOL_VERSION (COIBufferUnmap, 1) (COIMAPINSTANCE in_MapInstance,
|
|
uint32_t in_NumDependencies,
|
|
const COIEVENT *in_pDependencies, // Ignored
|
|
COIEVENT *out_pCompletion)
|
|
{
|
|
COITRACE ("COIBufferUnmap");
|
|
|
|
/* Features of liboffloadmic. */
|
|
assert (in_MapInstance != NULL);
|
|
assert (in_NumDependencies == 0);
|
|
|
|
/* Convert input arguments. */
|
|
Buffer *buffer = (Buffer *) in_MapInstance;
|
|
|
|
/* Only BUFFER_NORMAL buffers should come here. */
|
|
assert (buffer->type == BUFFER_NORMAL);
|
|
|
|
/* Unmap shared memory. */
|
|
if (munmap (buffer->data, buffer->size) < 0)
|
|
COIERROR ("Cannot unmap shared memory.");
|
|
|
|
buffer->data = 0;
|
|
|
|
if (out_pCompletion)
|
|
out_pCompletion->opaque[0] = 0;
|
|
|
|
return COI_SUCCESS;
|
|
}
|
|
|
|
|
|
COIRESULT
|
|
SYMBOL_VERSION (COIBufferWrite, 1) (COIBUFFER in_DestBuffer,
|
|
uint64_t in_Offset,
|
|
const void *in_pSourceData,
|
|
uint64_t in_Length,
|
|
COI_COPY_TYPE in_Type,
|
|
uint32_t in_NumDependencies,
|
|
const COIEVENT *in_pDependencies, // Ignored
|
|
COIEVENT *out_pCompletion)
|
|
{
|
|
COITRACE ("COIBufferWrite");
|
|
|
|
/* Features of liboffloadmic. */
|
|
assert (in_DestBuffer != NULL);
|
|
assert (in_pSourceData != NULL);
|
|
assert (in_Type == COI_COPY_UNSPECIFIED);
|
|
assert (in_NumDependencies == 0);
|
|
|
|
/* Convert input arguments. */
|
|
Buffer *buf = (Buffer *) in_DestBuffer;
|
|
|
|
start_critical_section ();
|
|
|
|
/* Map buffers if needed. */
|
|
if (buf->data == 0 && buf->type == BUFFER_NORMAL)
|
|
if (COIBufferMap (in_DestBuffer, 0, buf->size, (COI_MAP_TYPE) 0, 0, 0, 0, 0,
|
|
0) == COI_ERROR)
|
|
return COI_ERROR;
|
|
|
|
/* Copy data. */
|
|
memcpy ((void *) ((uintptr_t) buf->data + in_Offset), in_pSourceData,
|
|
in_Length);
|
|
|
|
/* Unmap buffers if needed. */
|
|
if (buf->type == BUFFER_NORMAL)
|
|
if (COIBufferUnmap ((COIMAPINSTANCE) buf, 0, 0, 0) == COI_ERROR)
|
|
return COI_ERROR;
|
|
|
|
finish_critical_section ();
|
|
|
|
if (out_pCompletion)
|
|
out_pCompletion->opaque[0] = 0;
|
|
|
|
return COI_SUCCESS;
|
|
}
|
|
|
|
|
|
COIRESULT
|
|
SYMBOL_VERSION (COIEngineGetCount, 1) (COI_ISA_TYPE isa,
|
|
uint32_t *count)
|
|
{
|
|
COITRACE ("COIEngineGetCount");
|
|
|
|
/* Features of liboffloadmic. */
|
|
assert (isa == COI_ISA_MIC);
|
|
assert (count != NULL);
|
|
|
|
/* Prepare output arguments. */
|
|
*count = num_engines;
|
|
|
|
return COI_SUCCESS;
|
|
}
|
|
|
|
|
|
COIRESULT
|
|
SYMBOL_VERSION (COIEngineGetHandle, 1) (COI_ISA_TYPE in_ISA,
|
|
uint32_t in_EngineIndex,
|
|
COIENGINE *out_pEngineHandle)
|
|
{
|
|
COITRACE ("COIEngineGetHandle");
|
|
|
|
/* Features of liboffloadmic. */
|
|
assert (in_ISA == COI_ISA_MIC);
|
|
assert (out_pEngineHandle != NULL);
|
|
|
|
/* Check engine index. */
|
|
if (in_EngineIndex >= num_engines)
|
|
COIERROR ("Wrong engine index.");
|
|
|
|
/* Create engine handle. */
|
|
Engine *engine = new Engine;
|
|
engine->dir = NULL;
|
|
engine->index = in_EngineIndex;
|
|
engine->type = in_ISA;
|
|
|
|
/* Prepare output argument. */
|
|
*out_pEngineHandle = (COIENGINE) engine;
|
|
|
|
return COI_SUCCESS;
|
|
}
|
|
|
|
|
|
COIRESULT
|
|
SYMBOL_VERSION (COIEventWait, 1) (uint16_t in_NumEvents,
|
|
const COIEVENT *in_pEvents,
|
|
int32_t in_TimeoutMilliseconds,
|
|
uint8_t in_WaitForAll,
|
|
uint32_t *out_pNumSignaled,
|
|
uint32_t *out_pSignaledIndices)
|
|
{
|
|
COITRACE ("COIEventWait");
|
|
|
|
/* Features of liboffloadmic. */
|
|
assert (in_pEvents != NULL);
|
|
assert (in_TimeoutMilliseconds == 0 || in_TimeoutMilliseconds == -1);
|
|
assert (in_WaitForAll == 1);
|
|
assert (out_pNumSignaled == NULL);
|
|
assert (out_pSignaledIndices == NULL);
|
|
|
|
if (in_TimeoutMilliseconds == 0)
|
|
{
|
|
/* If some event is not signalled, return timeout error. */
|
|
for (uint16_t i = 0; i < in_NumEvents; i++)
|
|
if (non_signalled_events.count (in_pEvents[i].opaque[0]) > 0)
|
|
return COI_TIME_OUT_REACHED;
|
|
else
|
|
{
|
|
/* If the event signalled with an error, return that error. */
|
|
start_critical_section ();
|
|
COIRESULT res = get_event_result (in_pEvents[i]);
|
|
finish_critical_section ();
|
|
if (res != COI_SUCCESS)
|
|
return res;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
/* Wait indefinitely for all events. */
|
|
for (uint16_t i = 0; i < in_NumEvents; i++)
|
|
{
|
|
while (non_signalled_events.count (in_pEvents[i].opaque[0]) > 0)
|
|
usleep (1000);
|
|
|
|
/* If the event signalled with an error, return that error. */
|
|
start_critical_section ();
|
|
COIRESULT res = get_event_result (in_pEvents[i]);
|
|
finish_critical_section ();
|
|
if (res != COI_SUCCESS)
|
|
return res;
|
|
}
|
|
}
|
|
|
|
return COI_SUCCESS;
|
|
}
|
|
|
|
|
|
COIRESULT
|
|
SYMBOL_VERSION (COIEventRegisterCallback, 1) (const COIEVENT in_Event,
|
|
COI_EVENT_CALLBACK in_Callback,
|
|
const void *in_UserData,
|
|
const uint64_t in_Flags)
|
|
{
|
|
COITRACE ("COIEventRegisterCallback");
|
|
|
|
/* Features of liboffloadmic. */
|
|
assert (in_Callback != NULL);
|
|
assert (in_UserData != NULL);
|
|
assert (in_Flags == 0);
|
|
|
|
start_critical_section ();
|
|
if (non_signalled_events.count (in_Event.opaque[0]) == 0)
|
|
{
|
|
/* If the event is already signalled, invoke the callback immediately. */
|
|
COIRESULT res = get_event_result (in_Event);
|
|
in_Callback (in_Event, res, in_UserData);
|
|
}
|
|
else
|
|
{
|
|
Callback callback;
|
|
callback.ptr = in_Callback;
|
|
callback.data = in_UserData;
|
|
callbacks.insert (std::pair <uint64_t, Callback> (in_Event.opaque[0],
|
|
callback));
|
|
}
|
|
finish_critical_section ();
|
|
|
|
return COI_SUCCESS;
|
|
}
|
|
|
|
|
|
/* The start routine for the COI pipeline thread. */
|
|
|
|
static void *
|
|
pipeline_thread_routine (void *in_Pipeline)
|
|
{
|
|
/* Convert input arguments. */
|
|
Pipeline *pipeline = (Pipeline *) in_Pipeline;
|
|
|
|
/* Open pipes. */
|
|
pipeline->pipe_host2tgt
|
|
= open (pipeline->pipe_host2tgt_path, O_CLOEXEC | O_WRONLY);
|
|
if (pipeline->pipe_host2tgt < 0)
|
|
COIERRORN ("Cannot open host-to-target pipe.");
|
|
pipeline->pipe_tgt2host
|
|
= open (pipeline->pipe_tgt2host_path, O_CLOEXEC | O_RDONLY);
|
|
if (pipeline->pipe_tgt2host < 0)
|
|
COIERRORN ("Cannot open target-to-host pipe.");
|
|
|
|
free (pipeline->pipe_host2tgt_path);
|
|
free (pipeline->pipe_tgt2host_path);
|
|
pipeline->pipe_host2tgt_path = NULL;
|
|
pipeline->pipe_tgt2host_path = NULL;
|
|
|
|
while (!pipeline->destroy)
|
|
if (pipeline->queue.empty ())
|
|
usleep (1000);
|
|
else
|
|
{
|
|
Function func = pipeline->queue.front ();
|
|
start_critical_section ();
|
|
pipeline->queue.pop ();
|
|
finish_critical_section ();
|
|
|
|
/* Send data to target. */
|
|
cmd_t cmd = CMD_PIPELINE_RUN_FUNCTION;
|
|
WRITEN (pipeline->pipe_host2tgt, &cmd, sizeof (cmd_t));
|
|
WRITEN (pipeline->pipe_host2tgt, &func.ptr, sizeof (void *));
|
|
WRITEN (pipeline->pipe_host2tgt, &func.num_buffers, sizeof (uint32_t));
|
|
for (uint32_t i = 0; i < func.num_buffers; i++)
|
|
{
|
|
WRITEN (pipeline->pipe_host2tgt, &func.bufs_size[i],
|
|
sizeof (uint64_t));
|
|
WRITEN (pipeline->pipe_host2tgt, &func.bufs_data_target[i],
|
|
sizeof (void *));
|
|
}
|
|
WRITEN (pipeline->pipe_host2tgt, &func.misc_data_len,
|
|
sizeof (uint16_t));
|
|
if (func.misc_data_len > 0)
|
|
WRITEN (pipeline->pipe_host2tgt, func.misc_data, func.misc_data_len);
|
|
WRITEN (pipeline->pipe_host2tgt, &func.return_value_len,
|
|
sizeof (uint16_t));
|
|
|
|
delete [] func.bufs_size;
|
|
delete [] func.bufs_data_target;
|
|
|
|
/* Receive data from target. Wait for target function to complete,
|
|
whether it has any data to return or not. */
|
|
bool has_return_value = func.return_value_len > 0;
|
|
int ret_len
|
|
= read (pipeline->pipe_tgt2host,
|
|
has_return_value ? func.return_value : &cmd,
|
|
has_return_value ? func.return_value_len : sizeof (cmd_t));
|
|
if (ret_len == 0)
|
|
{
|
|
start_critical_section ();
|
|
signal_event (func.completion_event, COI_PROCESS_DIED);
|
|
pipeline->is_destroyed = true;
|
|
finish_critical_section ();
|
|
return NULL;
|
|
}
|
|
else if (ret_len != (has_return_value ? func.return_value_len
|
|
: sizeof (cmd_t)))
|
|
COIERRORN ("Cannot read from pipe.");
|
|
|
|
start_critical_section ();
|
|
signal_event (func.completion_event, COI_SUCCESS);
|
|
finish_critical_section ();
|
|
}
|
|
|
|
/* Send data to target. */
|
|
const cmd_t cmd = CMD_PIPELINE_DESTROY;
|
|
WRITEN (pipeline->pipe_host2tgt, &cmd, sizeof (cmd_t));
|
|
|
|
/* Close pipes. */
|
|
if (close (pipeline->pipe_host2tgt) < 0)
|
|
COIERRORN ("Cannot close host-to-target pipe.");
|
|
if (close (pipeline->pipe_tgt2host) < 0)
|
|
COIERRORN ("Cannot close target-to-host pipe.");
|
|
|
|
start_critical_section ();
|
|
pipeline->is_destroyed = true;
|
|
finish_critical_section ();
|
|
return NULL;
|
|
}
|
|
|
|
|
|
COIRESULT
|
|
SYMBOL_VERSION (COIPipelineCreate, 1) (COIPROCESS in_Process,
|
|
COI_CPU_MASK in_Mask,
|
|
uint32_t in_StackSize, // Ignored
|
|
COIPIPELINE *out_pPipeline)
|
|
{
|
|
COITRACE ("COIPipelineCreate");
|
|
|
|
/* Features of liboffloadmic. */
|
|
assert (in_Process != NULL);
|
|
assert (in_Mask == 0);
|
|
assert (out_pPipeline != NULL);
|
|
|
|
/* Convert input arguments. */
|
|
Process *proc = (Process *) in_Process;
|
|
|
|
start_critical_section ();
|
|
|
|
/* Create pipeline handle. */
|
|
Pipeline *pipeline = new Pipeline;
|
|
pipeline->destroy = false;
|
|
pipeline->is_destroyed = false;
|
|
pipeline->process = proc;
|
|
pipelines.insert (pipeline);
|
|
|
|
/* Create pipes. */
|
|
uint32_t pipeline_num = max_pipeline_num++;
|
|
char *eng_dir = pipeline->process->engine->dir;
|
|
MALLOC (char *, pipeline->pipe_host2tgt_path,
|
|
strlen (eng_dir) + sizeof (PIPE_HOST2TGT_NAME "0000000000"));
|
|
MALLOC (char *, pipeline->pipe_tgt2host_path,
|
|
strlen (eng_dir) + sizeof (PIPE_TGT2HOST_NAME "0000000000"));
|
|
sprintf (pipeline->pipe_host2tgt_path, "%s" PIPE_HOST2TGT_NAME "%010d",
|
|
eng_dir, pipeline_num);
|
|
sprintf (pipeline->pipe_tgt2host_path, "%s" PIPE_TGT2HOST_NAME "%010d",
|
|
eng_dir, pipeline_num);
|
|
if (mkfifo (pipeline->pipe_host2tgt_path, S_IRUSR | S_IWUSR) < 0)
|
|
COIERROR ("Cannot create pipe %s.", pipeline->pipe_host2tgt_path);
|
|
if (mkfifo (pipeline->pipe_tgt2host_path, S_IRUSR | S_IWUSR) < 0)
|
|
COIERROR ("Cannot create pipe %s.", pipeline->pipe_tgt2host_path);
|
|
|
|
/* Send data to target. */
|
|
const cmd_t cmd = CMD_PIPELINE_CREATE;
|
|
WRITE (proc->pipe_host2tgt, &cmd, sizeof (cmd_t));
|
|
WRITE (proc->pipe_host2tgt, &pipeline_num, sizeof (pipeline_num));
|
|
|
|
/* Create a new thread for the pipeline. */
|
|
if (pthread_create (&pipeline->thread, NULL, pipeline_thread_routine,
|
|
pipeline))
|
|
COIERROR ("Cannot create new thread.");
|
|
|
|
finish_critical_section ();
|
|
|
|
/* Prepare output arguments. */
|
|
*out_pPipeline = (COIPIPELINE) pipeline;
|
|
|
|
return COI_SUCCESS;
|
|
}
|
|
|
|
|
|
COIRESULT
|
|
SYMBOL_VERSION (COIPipelineDestroy, 1) (COIPIPELINE in_Pipeline)
|
|
{
|
|
COITRACE ("COIPipelineDestroy");
|
|
|
|
assert (in_Pipeline != NULL);
|
|
|
|
/* Convert input arguments. */
|
|
Pipeline *pipeline = (Pipeline *) in_Pipeline;
|
|
|
|
start_critical_section ();
|
|
/* Remove pipeline from the set of undestroyed pipelines. */
|
|
pipelines.erase (pipeline);
|
|
|
|
/* Exit pipeline thread. */
|
|
pipeline->destroy = true;
|
|
finish_critical_section ();
|
|
|
|
while (!pipeline_is_destroyed (pipeline))
|
|
usleep (1000);
|
|
|
|
/* Join with a destroyed thread. */
|
|
if (pthread_join (pipeline->thread, NULL))
|
|
COIERROR ("Cannot join with a thread.");
|
|
|
|
delete pipeline;
|
|
|
|
return COI_SUCCESS;
|
|
}
|
|
|
|
|
|
COIRESULT
|
|
SYMBOL_VERSION (COIPipelineRunFunction, 1) (COIPIPELINE in_Pipeline,
|
|
COIFUNCTION in_Function,
|
|
uint32_t in_NumBuffers,
|
|
const COIBUFFER *in_Buffers,
|
|
const COI_ACCESS_FLAGS *in_pBufferAccessFlags, // Ignored
|
|
uint32_t in_NumDependencies,
|
|
const COIEVENT *in_pDependencies, // Ignored
|
|
const void *in_pMiscData,
|
|
uint16_t in_MiscDataLen,
|
|
void *out_pAsyncReturnValue,
|
|
uint16_t in_AsyncReturnValueLen,
|
|
COIEVENT *out_pCompletion)
|
|
{
|
|
COITRACE ("COIPipelineRunFunction");
|
|
|
|
/* Features of liboffloadmic. */
|
|
assert (in_Pipeline != NULL);
|
|
assert (in_Function != NULL);
|
|
assert (in_NumDependencies == 0);
|
|
|
|
Function func;
|
|
func.ptr = (void *) in_Function;
|
|
func.num_buffers = in_NumBuffers;
|
|
func.bufs_size = new uint64_t [in_NumBuffers];
|
|
func.bufs_data_target = new void * [in_NumBuffers];
|
|
for (uint32_t i = 0; i < in_NumBuffers; i++)
|
|
{
|
|
Buffer **bufs = (Buffer **) in_Buffers;
|
|
func.bufs_size[i] = bufs[i]->size;
|
|
func.bufs_data_target[i] = bufs[i]->data_target;
|
|
}
|
|
func.misc_data = (void *) in_pMiscData;
|
|
func.misc_data_len = in_MiscDataLen;
|
|
func.return_value = out_pAsyncReturnValue;
|
|
func.return_value_len = in_AsyncReturnValueLen;
|
|
|
|
start_critical_section ();
|
|
func.completion_event.opaque[0] = max_event_num++;
|
|
non_signalled_events.insert (func.completion_event.opaque[0]);
|
|
((Pipeline *) in_Pipeline)->queue.push (func);
|
|
finish_critical_section ();
|
|
|
|
/* In case of synchronous execution we have to wait for target. */
|
|
if (out_pCompletion == NULL)
|
|
COIEventWait (1, &func.completion_event, -1, 1, NULL, NULL);
|
|
else
|
|
*out_pCompletion = func.completion_event;
|
|
|
|
return COI_SUCCESS;
|
|
}
|
|
|
|
|
|
COIRESULT
|
|
SYMBOL_VERSION (COIProcessCreateFromMemory, 1) (COIENGINE in_Engine,
|
|
const char *in_pBinaryName,
|
|
const void *in_pBinaryBuffer,
|
|
uint64_t in_BinaryBufferLength,
|
|
int in_Argc,
|
|
const char **in_ppArgv,
|
|
uint8_t in_DupEnv,
|
|
const char **in_ppAdditionalEnv,
|
|
uint8_t in_ProxyActive, // Ignored
|
|
const char *in_Reserved, // Ignored
|
|
uint64_t in_InitialBufferSpace, // Ignored
|
|
const char *in_LibrarySearchPath,
|
|
const char *in_FileOfOrigin, // Ignored
|
|
uint64_t in_FileOfOriginOffset, // Ignored
|
|
COIPROCESS *out_pProcess)
|
|
{
|
|
COITRACE ("COIProcessCreateFromMemory");
|
|
|
|
const int run_max_args_num = 128;
|
|
char *run_argv[run_max_args_num];
|
|
char *emul_run = getenv (OFFLOAD_EMUL_RUN_ENV);
|
|
const int uint_max_len = 11;
|
|
|
|
/* Features of liboffloadmic. */
|
|
assert (in_Engine != NULL);
|
|
assert (in_pBinaryName != NULL);
|
|
assert (in_pBinaryBuffer != NULL);
|
|
assert (in_Argc == 0);
|
|
assert (in_ppArgv == NULL);
|
|
assert (in_ppAdditionalEnv == NULL);
|
|
assert (in_LibrarySearchPath != NULL);
|
|
assert (out_pProcess != NULL);
|
|
|
|
/* Convert input arguments. */
|
|
Engine *eng = (Engine *) in_Engine;
|
|
|
|
/* Create temporary directory for engine files. */
|
|
assert (eng->dir == NULL);
|
|
STRDUP (eng->dir, ENGINE_PATH);
|
|
if (mkdtemp (eng->dir) == NULL)
|
|
COIERROR ("Cannot create temporary directory %s.", eng->dir);
|
|
|
|
/* Save path to engine directory for clean up on exit. */
|
|
tmp_dirs_num++;
|
|
tmp_dirs = (char **) realloc (tmp_dirs, tmp_dirs_num * sizeof (char *));
|
|
if (!tmp_dirs)
|
|
COIERROR ("Cannot allocate memory.");
|
|
STRDUP (tmp_dirs[tmp_dirs_num - 1], eng->dir);
|
|
|
|
/* Create target executable file. */
|
|
char *target_exe;
|
|
MALLOC (char *, target_exe, strlen (eng->dir) + strlen (in_pBinaryName) + 2);
|
|
sprintf (target_exe, "%s/%s", eng->dir, in_pBinaryName);
|
|
int fd = open (target_exe, O_CLOEXEC | O_CREAT | O_WRONLY, S_IRUSR | S_IWUSR);
|
|
if (fd < 0)
|
|
COIERROR ("Cannot create file %s.", target_exe);
|
|
FILE *file = fdopen (fd, "wb");
|
|
if (file == NULL)
|
|
COIERROR ("Cannot associate stream with file descriptor.");
|
|
if (fwrite (in_pBinaryBuffer, 1, in_BinaryBufferLength, file)
|
|
!= in_BinaryBufferLength)
|
|
COIERROR ("Cannot write in file %s.", target_exe);
|
|
if (fclose (file) != 0)
|
|
COIERROR ("Cannot close file %s.", target_exe);
|
|
|
|
/* Fix file permissions. */
|
|
if (chmod (target_exe, S_IRWXU) < 0)
|
|
COIERROR ("Cannot change permissions for file %s.", target_exe);
|
|
|
|
/* Create directory for pipes to prevent names collision. */
|
|
char *pipes_path;
|
|
MALLOC (char *, pipes_path, strlen (eng->dir) + sizeof (PIPES_PATH));
|
|
sprintf (pipes_path, "%s" PIPES_PATH, eng->dir);
|
|
if (mkdir (pipes_path, S_IRWXU) < 0)
|
|
COIERROR ("Cannot create folder %s.", pipes_path);
|
|
|
|
/* Create 2 main pipes for inter-process communication. */
|
|
char *pipe_host2tgt_path, *pipe_tgt2host_path;
|
|
MALLOC (char *, pipe_host2tgt_path,
|
|
strlen (eng->dir) + sizeof (PIPE_HOST2TGT_NAME "mainpipe"));
|
|
MALLOC (char *, pipe_tgt2host_path,
|
|
strlen (eng->dir) + sizeof (PIPE_TGT2HOST_NAME "mainpipe"));
|
|
sprintf (pipe_host2tgt_path, "%s" PIPE_HOST2TGT_NAME "mainpipe", eng->dir);
|
|
sprintf (pipe_tgt2host_path, "%s" PIPE_TGT2HOST_NAME "mainpipe", eng->dir);
|
|
if (mkfifo (pipe_host2tgt_path, S_IRUSR | S_IWUSR) < 0)
|
|
COIERROR ("Cannot create main pipe %s.", pipe_host2tgt_path);
|
|
if (mkfifo (pipe_tgt2host_path, S_IRUSR | S_IWUSR) < 0)
|
|
COIERROR ("Cannot create main pipe %s.", pipe_tgt2host_path);
|
|
|
|
/* Prepare argv. */
|
|
if (emul_run == NULL || strcmp (emul_run, "") == 0)
|
|
{
|
|
STRDUP (run_argv[0], target_exe);
|
|
run_argv[1] = (char *) NULL;
|
|
}
|
|
else
|
|
{
|
|
char *ptr, *tmp;
|
|
int i = 0;
|
|
STRDUP (tmp, emul_run);
|
|
char *tok = strtok_r (tmp, " ", &ptr);
|
|
while (tok != NULL)
|
|
{
|
|
if (i >= run_max_args_num)
|
|
COIERROR ("Run command has too many arguments.");
|
|
STRDUP (run_argv[i++], tok);
|
|
tok = strtok_r (NULL, " ", &ptr);
|
|
}
|
|
STRDUP (run_argv[i], target_exe);
|
|
run_argv[i + 1] = (char *) NULL;
|
|
free (tmp);
|
|
}
|
|
|
|
/* Prepare envp. */
|
|
int env_num = 0;
|
|
if (in_DupEnv == true)
|
|
while (environ[env_num++]);
|
|
env_num += 4; // LD_LIBRARY_PATH, MIC_DIR, MIC_INDEX, NULL
|
|
|
|
char **envp;
|
|
MALLOC (char **, envp, env_num * sizeof (char *));
|
|
|
|
int env_i = 0;
|
|
if (in_DupEnv == true)
|
|
for (unsigned i = 0; environ[i] != NULL; i++)
|
|
{
|
|
unsigned j;
|
|
char *env_name;
|
|
STRDUP (env_name, environ[i]);
|
|
for (j = 0; env_name[j] != '=' && env_name[j] != '\0'; j++);
|
|
env_name[j] = '\0';
|
|
if (strcmp (env_name, "LD_LIBRARY_PATH") != 0
|
|
&& strcmp (env_name, MIC_DIR_ENV) != 0
|
|
&& strcmp (env_name, MIC_INDEX_ENV) != 0)
|
|
STRDUP (envp[env_i++], environ[i]);
|
|
free (env_name);
|
|
}
|
|
|
|
MALLOC (char *, envp[env_i], strlen (MIC_DIR_ENV) + strlen (eng->dir) + 2);
|
|
sprintf (envp[env_i], "%s=%s", MIC_DIR_ENV, eng->dir);
|
|
|
|
MALLOC (char *, envp[env_i + 1], strlen (MIC_INDEX_ENV) + uint_max_len + 1);
|
|
sprintf (envp[env_i + 1], "%s=%u", MIC_INDEX_ENV, eng->index);
|
|
|
|
MALLOC (char *, envp[env_i + 2],
|
|
strlen ("LD_LIBRARY_PATH=") + strlen (in_LibrarySearchPath) + 1);
|
|
sprintf (envp[env_i + 2], "LD_LIBRARY_PATH=%s", in_LibrarySearchPath);
|
|
|
|
envp[env_i + 3] = (char *) NULL;
|
|
|
|
/* Create target process. */
|
|
pid_t pid = vfork ();
|
|
if (pid < 0)
|
|
COIERROR ("Cannot create child process.");
|
|
|
|
if (pid == 0)
|
|
{
|
|
/* Run target executable. */
|
|
if (execvpe (run_argv[0], run_argv, envp) == -1)
|
|
COIERROR ("Cannot execute file %s.", target_exe);
|
|
}
|
|
|
|
/* Open main pipes. */
|
|
int pipe_host2tgt = open (pipe_host2tgt_path, O_CLOEXEC | O_WRONLY);
|
|
if (pipe_host2tgt < 0)
|
|
COIERROR ("Cannot open host-to-target main pipe.");
|
|
int pipe_tgt2host = open (pipe_tgt2host_path, O_CLOEXEC | O_RDONLY);
|
|
if (pipe_tgt2host < 0)
|
|
COIERROR ("Cannot open target-to-host main pipe.");
|
|
|
|
/* Create process handle. */
|
|
Process *proc = new Process;
|
|
proc->pid = pid;
|
|
proc->pipe_host2tgt = pipe_host2tgt;
|
|
proc->pipe_tgt2host = pipe_tgt2host;
|
|
proc->engine = eng;
|
|
proc->functions = NULL;
|
|
|
|
/* Prepare output arguments. */
|
|
*out_pProcess = (COIPROCESS) proc;
|
|
|
|
/* Clean up. */
|
|
for (unsigned i = 0; run_argv[i] != NULL; i++)
|
|
free (run_argv[i]);
|
|
for (unsigned i = 0; envp[i] != NULL; i++)
|
|
free (envp[i]);
|
|
free (envp);
|
|
free (pipe_host2tgt_path);
|
|
free (pipe_tgt2host_path);
|
|
free (pipes_path);
|
|
free (target_exe);
|
|
|
|
return COI_SUCCESS;
|
|
}
|
|
|
|
|
|
COIRESULT
|
|
SYMBOL_VERSION (COIProcessCreateFromFile, 1) (COIENGINE in_Engine,
|
|
const char *in_pBinaryName,
|
|
int in_Argc,
|
|
const char **in_ppArgv,
|
|
uint8_t in_DupEnv,
|
|
const char **in_ppAdditionalEnv,
|
|
uint8_t in_ProxyActive,
|
|
const char *in_Reserved,
|
|
uint64_t in_BufferSpace,
|
|
const char *in_LibrarySearchPath,
|
|
COIPROCESS *out_pProcess)
|
|
{
|
|
COITRACE ("COIProcessCreateFromFile");
|
|
|
|
/* liboffloadmic with GCC compiled binaries should never go here. */
|
|
assert (false);
|
|
return COI_ERROR;
|
|
}
|
|
|
|
|
|
COIRESULT
|
|
SYMBOL_VERSION (COIProcessDestroy, 1) (COIPROCESS in_Process,
|
|
int32_t in_WaitForMainTimeout, // Ignored
|
|
uint8_t in_ForceDestroy,
|
|
int8_t *out_pProcessReturn,
|
|
uint32_t *out_pTerminationCode)
|
|
{
|
|
COITRACE ("COIProcessDestroy");
|
|
|
|
assert (in_Process != NULL);
|
|
assert (out_pProcessReturn != NULL);
|
|
assert (out_pTerminationCode != NULL);
|
|
|
|
/* Convert input arguments. */
|
|
Process *proc = (Process *) in_Process;
|
|
|
|
/* Destroy all undestroyed pipelines. */
|
|
while (!pipelines.empty ())
|
|
{
|
|
std::set<Pipeline *>::iterator p = pipelines.begin ();
|
|
COIPipelineDestroy ((COIPIPELINE) *p);
|
|
}
|
|
|
|
/* Close main pipes. */
|
|
if (close (proc->pipe_host2tgt) < 0)
|
|
COIERROR ("Cannot close host-to-target main pipe.");
|
|
if (close (proc->pipe_tgt2host) < 0)
|
|
COIERROR ("Cannot close target-to-host main pipe.");
|
|
|
|
/* Shutdown target process by force. */
|
|
if (in_ForceDestroy)
|
|
kill (proc->pid, SIGTERM);
|
|
|
|
/* Clean up. */
|
|
free (proc->engine->dir);
|
|
free (proc->functions);
|
|
delete proc->engine;
|
|
delete proc;
|
|
|
|
/* Prepare output arguments. */
|
|
*out_pProcessReturn = 0;
|
|
*out_pTerminationCode = 0;
|
|
|
|
return COI_SUCCESS;
|
|
}
|
|
|
|
|
|
COIRESULT
|
|
SYMBOL_VERSION (COIProcessGetFunctionHandles, 1) (COIPROCESS in_Process,
|
|
uint32_t in_NumFunctions,
|
|
const char **in_ppFunctionNameArray,
|
|
COIFUNCTION *out_pFunctionHandleArray)
|
|
{
|
|
COITRACE ("COIProcessGetFunctionHandles");
|
|
|
|
assert (in_Process != NULL);
|
|
assert (in_ppFunctionNameArray != NULL);
|
|
assert (out_pFunctionHandleArray != NULL);
|
|
|
|
/* Convert input arguments. */
|
|
Process *proc = (Process *) in_Process;
|
|
|
|
/* This function should be called once for the process. */
|
|
assert (proc->functions == NULL);
|
|
|
|
/* Create array of function pointers. Last element is 0, what shows the end
|
|
of the array. This array is used to free memory when process is
|
|
destroyed. */
|
|
proc->functions = (void **) calloc (in_NumFunctions + 1, sizeof (void *));
|
|
if (proc->functions == NULL)
|
|
COIERROR ("Cannot allocate memory.");
|
|
|
|
/* Get handles for functions. */
|
|
for (uint32_t i = 0; i < in_NumFunctions; i++)
|
|
{
|
|
size_t len = strlen (in_ppFunctionNameArray[i]) + 1;
|
|
|
|
start_critical_section ();
|
|
|
|
/* Send data to target. */
|
|
const cmd_t cmd = CMD_GET_FUNCTION_HANDLE;
|
|
WRITE (proc->pipe_host2tgt, &cmd, sizeof (cmd_t));
|
|
WRITE (proc->pipe_host2tgt, &len, sizeof (size_t));
|
|
WRITE (proc->pipe_host2tgt, in_ppFunctionNameArray[i], len);
|
|
|
|
/* Receive data from target. */
|
|
void *fn_ptr;
|
|
READ (proc->pipe_tgt2host, &fn_ptr, sizeof (void *));
|
|
|
|
finish_critical_section ();
|
|
|
|
/* Save function pointer. */
|
|
proc->functions[i] = fn_ptr;
|
|
|
|
/* Prepare output arguments. */
|
|
out_pFunctionHandleArray[i] = (COIFUNCTION) fn_ptr;
|
|
}
|
|
|
|
return COI_SUCCESS;
|
|
}
|
|
|
|
|
|
COIRESULT
|
|
SYMBOL_VERSION (COIProcessLoadLibraryFromMemory, 2) (COIPROCESS in_Process,
|
|
const void *in_pLibraryBuffer,
|
|
uint64_t in_LibraryBufferLength,
|
|
const char *in_pLibraryName,
|
|
const char *in_LibrarySearchPath, // Ignored
|
|
const char *in_FileOfOrigin, // Ignored
|
|
uint64_t in_FileOfOriginOffset, // Ignored
|
|
uint32_t in_Flags, // Ignored
|
|
COILIBRARY *out_pLibrary)
|
|
{
|
|
COITRACE ("COIProcessLoadLibraryFromMemory");
|
|
|
|
assert (in_Process != NULL);
|
|
assert (in_pLibraryBuffer != NULL);
|
|
assert (out_pLibrary != NULL);
|
|
|
|
/* Convert input arguments. */
|
|
Process *proc = (Process *) in_Process;
|
|
|
|
/* Create target library file. */
|
|
char *lib_path;
|
|
size_t len = strlen (proc->engine->dir) + strlen (in_pLibraryName) + 2;
|
|
MALLOC (char *, lib_path, len);
|
|
sprintf (lib_path, "%s/%s", proc->engine->dir, in_pLibraryName);
|
|
int fd = open (lib_path, O_CLOEXEC | O_CREAT | O_WRONLY, S_IRUSR | S_IWUSR);
|
|
if (fd < 0)
|
|
COIERROR ("Cannot create file %s.", lib_path);
|
|
FILE *file = fdopen (fd, "wb");
|
|
if (file == NULL)
|
|
COIERROR ("Cannot associate stream with file descriptor.");
|
|
if (fwrite (in_pLibraryBuffer, 1, in_LibraryBufferLength, file)
|
|
!= in_LibraryBufferLength)
|
|
COIERROR ("Cannot write in file %s.", lib_path);
|
|
if (fclose (file) != 0)
|
|
COIERROR ("Cannot close file %s.", lib_path);
|
|
|
|
start_critical_section ();
|
|
|
|
/* Make target open library. */
|
|
const cmd_t cmd = CMD_OPEN_LIBRARY;
|
|
WRITE (proc->pipe_host2tgt, &cmd, sizeof (cmd_t));
|
|
WRITE (proc->pipe_host2tgt, &len, sizeof (size_t));
|
|
WRITE (proc->pipe_host2tgt, lib_path, len);
|
|
|
|
/* Receive data from target. */
|
|
void *handle;
|
|
READ (proc->pipe_tgt2host, &handle, sizeof (void *));
|
|
|
|
finish_critical_section ();
|
|
|
|
/* Clean up. */
|
|
free (lib_path);
|
|
|
|
*out_pLibrary = (COILIBRARY) handle;
|
|
return COI_SUCCESS;
|
|
}
|
|
|
|
|
|
COIRESULT
|
|
SYMBOL_VERSION (COIProcessRegisterLibraries, 1) (uint32_t in_NumLibraries, // Ignored
|
|
const void **in_ppLibraryArray, // Ignored
|
|
const uint64_t *in_pLibrarySizeArray, // Ignored
|
|
const char **in_ppFileOfOriginArray, // Ignored
|
|
const uint64_t *in_pFileOfOriginOffSetArray) // Ignored
|
|
{
|
|
COITRACE ("COIProcessRegisterLibraries");
|
|
|
|
/* Looks like we have nothing to do here. */
|
|
|
|
return COI_SUCCESS;
|
|
}
|
|
|
|
|
|
COIRESULT
|
|
SYMBOL_VERSION (COIProcessUnloadLibrary, 1) (COIPROCESS in_Process,
|
|
COILIBRARY in_Library)
|
|
{
|
|
COITRACE ("COIProcessUnloadLibrary");
|
|
|
|
assert (in_Process != NULL);
|
|
assert (in_Library != NULL);
|
|
|
|
const cmd_t cmd = CMD_CLOSE_LIBRARY;
|
|
|
|
/* Convert input arguments. */
|
|
Process *proc = (Process *) in_Process;
|
|
|
|
start_critical_section ();
|
|
|
|
/* Make target close library. */
|
|
WRITE (proc->pipe_host2tgt, &cmd, sizeof (cmd_t));
|
|
WRITE (proc->pipe_host2tgt, &in_Library, sizeof (void *));
|
|
|
|
finish_critical_section ();
|
|
|
|
return COI_SUCCESS;
|
|
}
|
|
|
|
|
|
uint64_t
|
|
SYMBOL_VERSION (COIPerfGetCycleFrequency, 1) ()
|
|
{
|
|
COITRACE ("COIPerfGetCycleFrequency");
|
|
|
|
return (uint64_t) CYCLE_FREQUENCY;
|
|
}
|
|
|
|
|
|
COIRESULT
|
|
SYMBOL_VERSION (COIPipelineClearCPUMask, 1) (COI_CPU_MASK *in_Mask)
|
|
{
|
|
COITRACE ("COIPipelineClearCPUMask");
|
|
|
|
/* Looks like we have nothing to do here. */
|
|
|
|
return COI_SUCCESS;
|
|
}
|
|
|
|
|
|
COIRESULT
|
|
SYMBOL_VERSION (COIPipelineSetCPUMask, 1) (COIPROCESS in_Process,
|
|
uint32_t in_CoreID,
|
|
uint8_t in_ThreadID,
|
|
COI_CPU_MASK *out_pMask)
|
|
{
|
|
COITRACE ("COIPipelineSetCPUMask");
|
|
|
|
/* Looks like we have nothing to do here. */
|
|
|
|
return COI_SUCCESS;
|
|
}
|
|
|
|
|
|
COIRESULT
|
|
SYMBOL_VERSION (COIEngineGetInfo, 1) (COIENGINE in_EngineHandle, // Ignored
|
|
uint32_t in_EngineInfoSize, // Ignored
|
|
COI_ENGINE_INFO *out_pEngineInfo)
|
|
{
|
|
COITRACE ("COIEngineGetInfo");
|
|
|
|
assert (out_pEngineInfo != NULL);
|
|
|
|
out_pEngineInfo->ISA = COI_DEVICE_KNL;
|
|
out_pEngineInfo->NumCores = 1;
|
|
out_pEngineInfo->NumThreads = 8;
|
|
out_pEngineInfo->CoreMaxFrequency = SYMBOL_VERSION(COIPerfGetCycleFrequency,1)() / 1000000;
|
|
out_pEngineInfo->PhysicalMemory = 1024;
|
|
out_pEngineInfo->PhysicalMemoryFree = 1024;
|
|
out_pEngineInfo->SwapMemory = 1024;
|
|
out_pEngineInfo->SwapMemoryFree = 1024;
|
|
out_pEngineInfo->MiscFlags = COI_ENG_ECC_DISABLED;
|
|
|
|
return COI_SUCCESS;
|
|
}
|
|
|
|
} // extern "C"
|
|
|