void client_send_to_monitor(Client *c, Monitor *m) {
if(c->mon == m)
return;
client_unfocus(c, true);
client_detach(c);
client_detach_stack(c);
c->mon = m;
c->tags = m->tagset[m->seltags]; /* assign tags of target monitor */
client_attach(c);
client_attach_stack(c);
client_focus(NULL);
arrange(NULL);
}
void gmm_init(void)
{
INTERCEPT_CUDA("cudaMalloc", nv_cudaMalloc);
INTERCEPT_CUDA("cudaFree", nv_cudaFree);
INTERCEPT_CUDA("cudaMemcpy", nv_cudaMemcpy);
INTERCEPT_CUDA("cudaMemcpyAsync", nv_cudaMemcpyAsync);
INTERCEPT_CUDA("cudaStreamCreate", nv_cudaStreamCreate);
INTERCEPT_CUDA("cudaStreamDestroy", nv_cudaStreamDestroy);
INTERCEPT_CUDA("cudaStreamSynchronize", nv_cudaStreamSynchronize);
INTERCEPT_CUDA("cudaMemGetInfo", nv_cudaMemGetInfo);
INTERCEPT_CUDA("cudaSetupArgument", nv_cudaSetupArgument);
INTERCEPT_CUDA("cudaConfigureCall", nv_cudaConfigureCall);
INTERCEPT_CUDA("cudaMemset", nv_cudaMemset);
//INTERCEPT_CUDA2("cudaMemsetAsync", nv_cudaMemsetAsync);
//INTERCEPT_CUDA2("cudaDeviceSynchronize", nv_cudaDeviceSynchronize);
INTERCEPT_CUDA("cudaLaunch", nv_cudaLaunch);
INTERCEPT_CUDA("cudaStreamAddCallback", nv_cudaStreamAddCallback);
gprint_init();
if (gmm_context_init() == -1) {
gprint(FATAL, "failed to initialize GMM local context\n");
return;
}
if (client_attach() == -1) {
gprint(FATAL, "failed to attach to the GMM global arena\n");
gmm_context_fini();
return;
}
// Before marking GMM context initialized, invoke an NV function
// to initialize CUDA runtime and let whatever memory regions
// implicitly required by CUDA runtime be allocated now. Those
// regions should be always attached and not managed by GMM runtime.
do {
size_t dummy;
nv_cudaMemGetInfo(&dummy, &dummy);
} while (0);
initialized = 1;
gprint(DEBUG, "gmm initialized\n");
}
/** Set the client as master
* \param c Client
*/
void
layout_set_client_master(Client *c)
{
screen_get_sel();
if(!c || (c->flags & HintFlag) || !(c->flags & TileFlag)
|| (c->flags & FSSFlag))
return;
if(c == tiled_client(selscreen, clients))
CHECK((c = tiled_client(selscreen, c->next)));
client_detach(c);
client_attach(c);
tags[selscreen][seltag[selscreen]].layout.func(selscreen);
return;
}
int client_launch_exec (int forkit, char *dir, char* argv[], struct server *s) {
int pid;
int pipefds[2];
int flags;
char msg[CLIENT_ERROR_BUFFER];
if (get_debug_level() || dontlaunch) {
char* cmdline = g_strjoinv(" # ",argv);
debug(0,"%s",cmdline);
g_free(cmdline);
}
if (dontlaunch)
return -1;
script_action_gamestart(NULL, s);
if (forkit) {
if (pipe (pipefds) < 0) {
dialog_failed ("pipe", NULL);
return -1;
}
pid = fork ();
if (pid == -1) {
dialog_failed ("fork", NULL);
return -1;
}
if (pid) { /* parent */
close (pipefds[1]);
flags = fcntl (pipefds[0], F_GETFL, 0);
if (flags < 0 || fcntl (pipefds[0], F_SETFL, flags | O_NONBLOCK) < 0) {
dialog_failed ("fcntl", NULL);
return -1;
}
client_attach (pid, pipefds[0], s);
}
else { /* child */
close_fds(pipefds[1]);
if (dir && dir[0] != '\0') {
if (chdir (dir) != 0) {
g_snprintf (msg, CLIENT_ERROR_BUFFER, "%schdir failed: %s",
CLIENT_ERROR_MSG_HEAD, g_strerror (errno));
goto error_out;
}
}
server_set_env(s);
execvp (argv[0], argv);
g_snprintf (msg, CLIENT_ERROR_BUFFER, "%sexec(%s) failed: %s",
CLIENT_ERROR_MSG_HEAD, argv[0], g_strerror (errno));
error_out:
write (pipefds[1], msg, strlen (msg) + 1);
close (pipefds[1]);
on_sig (SIGHUP, _exit);
on_sig (SIGINT, _exit);
on_sig (SIGQUIT, _exit);
on_sig (SIGBUS, _exit);
on_sig (SIGSEGV, _exit);
on_sig (SIGPIPE, _exit);
on_sig (SIGTERM, _exit);
on_sig (SIGALRM, _exit);
on_sig (SIGCHLD, SIG_DFL);
_exit (1);
}
return pid;
}
execvp (argv[0], argv);
dialog_failed ("exec", argv[0]);
return -1;
}
static __inline__ void
jpf_service_connect(jpf_service *ps)
{
int32_t sock, err;
struct sockaddr_in sin;
client *c;
tr_server *server;
err = unix_resolve_host(&sin, ps->psp.ip, ps->psp.port);
if (err)
{
LOG_W(
"jpf_service_connect()->unix_resolve_host() failed, ip:%s.",
ps->psp.ip
);
goto __conn_err;
}
sock = unix_sock_bind(L4_TCP, 0, 0, 0);
if (sock < 0)
{
LOG_W(
"jpf_service_connect()->unix_sock_bind() failed."
);
err = sock;
goto __conn_err;
}
if (connect(sock, (struct sockaddr*)&sin, sizeof(sin)) < 0)
{
err = -errno;
LOG_W(
"jpf_service_connect()->connect() failed, err:'%d'.",
err
);
goto __conn_err;
}
c = rtsp_impl_ts_client_new(0, (void*)sock);
if (!c)
{
LOG_W(
"jpf_service_connect()->rtsp_impl_ts_client_new() failed."
);
close(sock);
err = -ENOMEM;
goto __conn_err;
}
server = avs_get_server();
if (!server)
{
LOG_W(
"jpf_service_connect()->avs_get_server() failed."
);
client_kill_unref((client*)c);
err = -EPERM;
goto __conn_err;
}
client_attach(c, server->sched);
ps->jpf_client = (rtsp_ts_client*)c;
ps->ttl = 0;
LOG_I(
"Connect MDS '%s:%d' ok.", ps->psp.ip, ps->psp.port
);
return;
__conn_err:
if (ps->psp.exp_notifier)
{
(*ps->psp.exp_notifier)(ps->psp.user_data, err);
}
return;
}
