libs/ardour/worker.cc

   1 /*
   2   Copyright (C) 2012 Paul Davis
   3   Author: David Robillard
   4
   5   This program is free software; you can redistribute it and/or modify
   6   it under the terms of the GNU General Public License as published by
   7   the Free Software Foundation; either version 2 of the License, or
   8   (at your option) any later version.
   9
  10   This program is distributed in the hope that it will be useful,
  11   but WITHOUT ANY WARRANTY; without even the implied warranty of
  12   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13   GNU General Public License for more details.
  14
  15   You should have received a copy of the GNU General Public License
  16   along with this program; if not, write to the Free Software
  17   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  18 */
  19
  20 #include <stdlib.h>
  21
  22 #include "ardour/worker.h"
  23 #include "pbd/error.h"
  24
  25 namespace ARDOUR {
  26
  27 Worker::Worker(Workee* workee, uint32_t ring_size)
  28         : _workee(workee)
  29         , _requests(new RingBuffer<uint8_t>(ring_size))
  30         , _responses(new RingBuffer<uint8_t>(ring_size))
  31         , _response((uint8_t*)malloc(ring_size))
  32         , _sem(0)
  33         , _exit(false)
  34         , _thread (Glib::Threads::Thread::create(sigc::mem_fun(*this, &Worker::run)))
  35 {}
  36
  37 Worker::~Worker()
  38 {
  39         _exit = true;
  40         _sem.post();
  41         _thread->join();
  42 }
  43
  44 bool
  45 Worker::schedule(uint32_t size, const void* data)
  46 {
  47         if (_requests->write((const uint8_t*)&size, sizeof(size)) != sizeof(size)) {
  48                 return false;
  49         }
  50         if (_requests->write((const uint8_t*)data, size) != size) {
  51                 return false;  // FIXME: corruption
  52         }
  53         _sem.post();
  54         return true;
  55 }
  56
  57 bool
  58 Worker::respond(uint32_t size, const void* data)
  59 {
  60         if (_responses->write((const uint8_t*)&size, sizeof(size)) != sizeof(size)) {
  61                 return false;
  62         }
  63         if (_responses->write((const uint8_t*)data, size) != size) {
  64                 return false;  // FIXME: corruption
  65         }
  66         return true;
  67 }
  68
  69 void
  70 Worker::emit_responses()
  71 {
  72         uint32_t read_space = _responses->read_space();
  73         uint32_t size       = 0;
  74         while (read_space > sizeof(size)) {
  75                 _responses->read((uint8_t*)&size, sizeof(size));
  76                 _responses->read(_response, size);
  77                 _workee->work_response(size, _response);
  78                 read_space -= sizeof(size) + size;
  79         }
  80 }
  81
  82 void
  83 Worker::run()
  84 {
  85         void*  buf      = NULL;
  86         size_t buf_size = 0;
  87         while (true) {
  88                 _sem.wait();
  89                 if (_exit) {
  90                         return;
  91                 }
  92
  93                 uint32_t size = 0;
  94                 if (_requests->read((uint8_t*)&size, sizeof(size)) < sizeof(size)) {
  95                         PBD::error << "Worker: Error reading size from request ring"
  96                                    << endmsg;
  97                         continue;
  98                 }
  99
 100                 if (size > buf_size) {
 101                         buf = realloc(buf, size);
 102                         buf_size = size;
 103                 }
 104
 105                 if (_requests->read((uint8_t*)buf, size) < size) {
 106                         PBD::error << "Worker: Error reading body from request ring"
 107                                    << endmsg;
 108                         continue;  // TODO: This is probably fatal
 109                 }
 110
 111                 _workee->work(size, buf);
 112         }
 113 }
 114
 115 } // namespace ARDOUR