Maximizing Nvidia production

@Tom

I don't see where you are excluding 3 of 5 GPUs from your machine in the cc_config file.  From what I see, you would be using all GPUs for GW. Where did you put the <exclude>?
Z

To decrease CPU-usage I have tried this: (with lowered CPU usage, higher GPU utilization and lower throughput :( 

1) Modify this:

#define _GNU_SOURCE
#include <time.h>
#include <errno.h>
#include <dlfcn.h>
#include <poll.h>
#include <CL/cl.h>


/*
 * To compile run:
 * gcc -O2 -fPIC -shared -Wl,-soname,libsleep.so -o libsleep.so libsleep.c
 *
 * To use (with seti@home): (modify to suit your needs)
 *  daemon --check $BOINCEXE --user $BOINCUSER +10 "LD_PRELOAD=/etc/init.d/libsleep.so $BOINCEXE $BOINCOPTS --dir $BOINCDIR >>$LOGFILE 2>>$ERRORLOG &" >& /dev/null
*
*
*
*/

void testing(void) __attribute__((constructor));

void testing(void)
{
  //
}

int myInternalSleep(int us)
{
  struct timespec t;
  struct timespec r;

  t.tv_sec  = 0;
  t.tv_nsec = 1000L * (long)us; // 1 us

  nanosleep(&t, &r); // never mind if interrupted
 
  /*
  while(nanosleep(&t, &r) == -1 && errno == EINTR)
    { //continue sleeping if interrupted
      t.tv_sec = r.tv_sec;
      t.tv_nsec = r.tv_nsec;
    }
  */
 
  return 0;
}


int sched_yield(void)
{
  myInternalSleep(1);
}

/*
static int (*original_clFinish)(cl_command_queue a) = NULL;
*/

int clFinish(cl_command_queue a)
{
  int (*original_clFinish)(cl_command_queue a);
  //if(original_clFinish == NULL)
  original_clFinish = dlsym(RTLD_NEXT, "clFinish");
 
  myInternalSleep(1);
 
  int ret = (*original_clFinish)(a);

  return ret;
}

/*
static int (*original_pthread_cond_wait)(void *cond, void *mutex) = NULL;

int pthread_cond_wait(void *cond, void *mutex)
{
  if(original_pthread_cond_wait == NULL)
    original_pthread_cond_wait = dlsym(RTLD_NEXT, "pthread_cond_wait");
 
  myInternalSleep(10);
 
  return original_pthread_cond_wait(cond, mutex);
}


static int (*original_poll)(struct pollfd fds[], nfds_t nfds, int timeout) = NULL;

int poll(struct pollfd fds[], nfds_t nfds, int timeout)
{
  if(original_poll == NULL)
    original_poll = dlsym(RTLD_NEXT, "poll");
 
  myInternalSleep(10);
 
  return original_poll(fds, nfds, timeout);
}
*/

/*

static cl_int (*original_clEnqueueNDRangeKernel)(cl_command_queue command_queue,
                    cl_kernel kernel,
                    cl_uint work_dim,
                    const size_t *global_work_offset,
                    const size_t *global_work_size,
                    const size_t *local_work_size,
                    cl_uint num_events_in_wait_list,
                    const cl_event *event_wait_list,
                    cl_event *event) = NULL;
*/
static int w = 3;
cl_int clEnqueueNDRangeKernel(cl_command_queue command_queue,
                    cl_kernel kernel,
                    cl_uint work_dim,
                    const size_t *global_work_offset,
                    const size_t *global_work_size,
                    const size_t *local_work_size,
                    cl_uint num_events_in_wait_list,
                    const cl_event *event_wait_list,
                    cl_event *event)
{
  cl_int (*original_clEnqueueNDRangeKernel)(cl_command_queue command_queue,
                        cl_kernel kernel,
                        cl_uint work_dim,
                        const size_t *global_work_offset,
                        const size_t *global_work_size,
                        const size_t *local_work_size,
                        cl_uint num_events_in_wait_list,
                        const cl_event *event_wait_list,
                        cl_event *event) = NULL;
  //if(original_clEnqueueNDRangeKernel == NULL)
  original_clEnqueueNDRangeKernel = dlsym(RTLD_NEXT, "clEnqueueNDRangeKernel");
 
  cl_int i = original_clEnqueueNDRangeKernel(command_queue,
                     kernel,
                     work_dim,
                     global_work_offset,
                     global_work_size,
                     local_work_size,
                     num_events_in_wait_list,
                     event_wait_list,
                     event);

  myInternalSleep(w);

  w = (w + 191) & 255;
 
  return i;
}

/*
CLFFTAPI clfftStatus    clfftEnqueueTransform(
                                                clfftPlanHandle plHandle,
                                                clfftDirection dir,
                                                cl_uint numQueuesAndEvents,
                                                cl_command_queue* commQueues,
                                                cl_uint numWaitEvents,
                                                const cl_event* waitEvents,
                                                cl_event* outEvents,
                                                cl_mem* inputBuffers,
                                                cl_mem* outputBuffers,
                                                cl_mem tmpBuffer
                                                );
*/

//To be implemented

2) Suspend GPU work.

# gcc -I/usr/local/cuda-10.2/targets/x86_64-linux/include/ -O2 -fPIC -shared -Wl,-soname,libsleep.so -o libsleep.so libsleep.c

# cp ~myhome/libsleep/libsleep.so /usr/lib/libsleep.so
# sync

3) resume GPU work.