libs/pbd/pbd/abstract_ui.cc

   1 #include <unistd.h>
   2
   3 #include <pbd/abstract_ui.h>
   4 #include <pbd/pthread_utils.h>
   5 #include <pbd/failed_constructor.h>
   6
   7 #include "i18n.h"
   8
   9 using namespace std;
  10
  11 template <typename RequestObject>
  12 AbstractUI<RequestObject>::AbstractUI (string name, bool with_signal_pipes)
  13         : BaseUI (name, with_signal_pipes)
  14 {
  15         if (pthread_key_create (&thread_request_buffer_key, 0)) {
  16                 cerr << _("cannot create thread request buffer key") << endl;
  17                 throw failed_constructor();
  18         }
  19
  20         PBD::ThreadCreated.connect (mem_fun (*this, &AbstractUI<RequestObject>::register_thread));
  21         PBD::ThreadCreatedWithRequestSize.connect (mem_fun (*this, &AbstractUI<RequestObject>::register_thread_with_request_count));
  22 }
  23
  24 template <typename RequestObject> void
  25 AbstractUI<RequestObject>::register_thread (pthread_t thread_id, string name)
  26 {
  27         register_thread_with_request_count (thread_id, name, 256);
  28 }
  29
  30 template <typename RequestObject> void
  31 AbstractUI<RequestObject>::register_thread_with_request_count (pthread_t thread_id, string thread_name, uint32_t num_requests)
  32 {
  33         RequestBuffer* b = new RequestBuffer (num_requests);
  34
  35         {
  36         Glib::Mutex::Lock lm (request_buffer_map_lock);
  37                 request_buffers[thread_id] = b;
  38         }
  39
  40         pthread_setspecific (thread_request_buffer_key, b);
  41 }
  42
  43 template <typename RequestObject> RequestObject*
  44 AbstractUI<RequestObject>::get_request (RequestType rt)
  45 {
  46         RequestBuffer* rbuf = static_cast<RequestBuffer*>(pthread_getspecific (thread_request_buffer_key));
  47
  48         if (rbuf == 0) {
  49                 /* Cannot happen, but if it does we can't use the error reporting mechanism */
  50                 cerr << _("programming error: ")
  51                      << string_compose ("no %1-UI request buffer found for thread %2", name(), pthread_name())
  52                      << endl;
  53                 abort ();
  54         }
  55
  56         RequestBufferVector vec;
  57
  58         rbuf->get_write_vector (&vec);
  59
  60         if (vec.len[0] == 0) {
  61                 if (vec.len[1] == 0) {
  62                         cerr << string_compose ("no space in %1-UI request buffer for thread %2", name(), pthread_name())
  63                              << endl;
  64                         return 0;
  65                 } else {
  66                         vec.buf[1]->type = rt;
  67                         return vec.buf[1];
  68                 }
  69         } else {
  70                 vec.buf[0]->type = rt;
  71                 return vec.buf[0];
  72         }
  73 }
  74
  75 template <typename RequestObject> void
  76 AbstractUI<RequestObject>::handle_ui_requests ()
  77 {
  78         RequestBufferMapIterator i;
  79
  80         request_buffer_map_lock.lock ();
  81
  82         for (i = request_buffers.begin(); i != request_buffers.end(); ++i) {
  83
  84                 RequestBufferVector vec;
  85
  86                 while (true) {
  87
  88                         /* we must process requests 1 by 1 because
  89                            the request may run a recursive main
  90                            event loop that will itself call
  91                            handle_ui_requests. when we return
  92                            from the request handler, we cannot
  93                            expect that the state of queued requests
  94                            is even remotely consistent with
  95                            the condition before we called it.
  96                         */
  97
  98                         i->second->get_read_vector (&vec);
  99
 100                         if (vec.len[0] == 0) {
 101                                 break;
 102                         } else {
 103                                 /* request_factory/copy constructor does a deep
 104                                    copy of the Request object,
 105                                    unlike Ringbuffer::read()
 106                                 */
 107
 108                                 request_buffer_map_lock.unlock ();
 109                                 do_request (vec.buf[0]);
 110                                 request_buffer_map_lock.lock ();
 111                                 i->second->increment_read_ptr (1);
 112                         }
 113                 }
 114         }
 115
 116         request_buffer_map_lock.unlock ();
 117 }
 118
 119 template <typename RequestObject> void
 120 AbstractUI<RequestObject>::send_request (RequestObject *req)
 121 {
 122         if (base_instance() == 0) {
 123                 return; /* XXX is this the right thing to do ? */
 124         }
 125
 126         if (caller_is_ui_thread()) {
 127                 // cerr << "GUI thread sent request " << req << " type = " << req->type << endl;
 128                 do_request (req);
 129         } else {
 130                 RequestBuffer* rbuf = static_cast<RequestBuffer*> (pthread_getspecific (thread_request_buffer_key));
 131
 132                 if (rbuf == 0) {
 133                         /* can't use the error system to report this, because this
 134                            thread isn't registered!
 135                         */
 136                         cerr << _("programming error: ")
 137                              << string_compose ("AbstractUI::send_request() called from %1 (%2), but no request buffer exists for that thread", name(), pthread_name())
 138                              << endl;
 139                         abort ();
 140                 }
 141
 142                 // cerr << "thread " << pthread_self() << " sent request " << req << " type = " << req->type << endl;
 143
 144                 rbuf->increment_write_ptr (1);
 145
 146                 if (signal_pipe[1] >= 0) {
 147                         const char c = 0;
 148                         write (signal_pipe[1], &c, 1);
 149                 }
 150         }
 151 }
 152