Changeset 21348

Timestamp:

10/15/08 11:41:06 (5 years ago)

Author:

frsyuki

Message:

lang/c/mpio: improved exception handling

Location:

lang/c/mpio/trunk

Files:

• Makefile.am (modified) (1 diff)
• mp/Makefile (modified) (1 diff)
• mp/coroutine.h (modified) (1 diff)
• mp/event.pre.h (modified) (1 diff)
• mp/exception.h (added)
• mp/fdnotify.h (modified) (2 diffs)
• mp/fdnotify_impl.h (modified) (4 diffs)
• mp/iothreads.pre.h (modified) (2 diffs)
• mp/iothreads_impl.pre.h (modified) (2 diffs)
• mp/pthread.h (modified) (3 diffs)
• mp/pthread_impl.h (modified) (5 diffs)
• mp/system/buffered_kqueue_impl.h (modified) (1 diff)
• mp/system/epoll_impl.h (modified) (1 diff)
• mp/system/kqueue_impl.h (modified) (1 diff)
• mp/utility.pre.h (modified) (2 diffs)
• mp/zone_impl.pre.h (modified) (1 diff)
• src/iothreads.cc (modified) (1 diff)
• src/iothreads_connector.cc (modified) (2 diffs)
• src/iothreads_listener.cc (modified) (3 diffs)
• src/iothreads_reader.cc (modified) (5 diffs)
• src/iothreads_writer.cc (modified) (4 diffs)

lang/c/mpio/trunk/Makefile.am

@@ -17 +17 @@
                 mp/event.h \
                 mp/event_impl.h \
+                mp/exception.h \
                 mp/fdnotify.h \
                 mp/fdnotify_impl.h \

lang/c/mpio/trunk/mp/Makefile

@@ -68 +68 @@
         $< > $@
 
-.PHONY: clean
+.PHONY: clean install distdir
 clean:
         $(RM) $(NEED_PREPROCESS)
 
-install:
-        # dummy
-
-distdir:

lang/c/mpio/trunk/mp/coroutine.h

@@ -71 +71 @@
         static void join(handler& target)
                 { s_instance->join_impl(target); }
+
+        //! Return current handler
+        static handler& current()
+                { return *s_current; }
 
         //! Resume suspended handler's routine.

lang/c/mpio/trunk/mp/event.pre.h

@@ -21 +21 @@
 
 #include "mp/system/config.h"
+#include "mp/exception.h"
 #include "mp/utility.h"
 #include "mp/sparse_array.h"

lang/c/mpio/trunk/mp/fdnotify.h

@@ -20 +20 @@
 #define MP_FDNOTIFY_H__
 
-#include <sys/types.h>
-#include <sys/uio.h>
-#include <unistd.h>
-#include <stdexcept>
+#include "mp/exception.h"
 
 #ifndef MP_FDNOTIFY_VECTOR_SIZE
-#define MP_FDNOTIFY_VECTOR_SIZE 64
+#define MP_FDNOTIFY_VECTOR_SIZE 32
 #endif
 
@@ -32 +29 @@
 
 
-struct fdnotify_exception : public std::runtime_error {
-        fdnotify_exception(const std::string& msg) :
-                std::runtime_error(msg) {}
+struct fdnotify_error : system_error {
+        fdnotify_error(int errno_, const std::string& msg) :
+                system_error(errno_, msg) {}
 };
 

lang/c/mpio/trunk/mp/fdnotify_impl.h

@@ -20 +20 @@
 #define MP_FDNOTIFY_IMPL_H__
 
+#include <sys/types.h>
+#include <sys/uio.h>
+#include <unistd.h>
 #include <fcntl.h>
 #include <errno.h>
@@ -30 +33 @@
 {
         if( ::pipe(m_pipe) < 0 ) {
-                throw fdnotify_exception("can't create pipe");
+                throw fdnotify_error(errno, "can't create pipe");
         }
         if( ::fcntl(m_pipe[0], F_SETFL, O_NONBLOCK) < 0 ) {
                 ::close(m_pipe[0]);
                 ::close(m_pipe[1]);
-                throw fdnotify_exception("can't set non-blocking mode");
+                throw fdnotify_error(errno, "can't set non-blocking mode");
         }
 }
@@ -69 +72 @@
                 if(len < 0) {
                         if(errno != EAGAIN && errno != EINTR) {
-                                throw fdnotify_exception("write-side pipe is broken");
+                                throw fdnotify_error(errno, "write-side pipe is broken");
                         }
                 } else if(len == 0) {
-                        throw fdnotify_exception("write-side pipe is closed");
+                        throw fdnotify_error(errno, "write-side pipe is closed");
                 }
         }
@@ -91 +94 @@
                         return false;
                 } else {
-                        throw fdnotify_exception("read-side pipe is broken");
+                        throw fdnotify_error(errno, "read-side pipe is broken");
                 }
         } else if(len == 0) {
-                throw fdnotify_exception("read-side pipe is closed");
+                throw fdnotify_error(errno, "read-side pipe is closed");
         }
 

lang/c/mpio/trunk/mp/iothreads.pre.h

@@ -62 +62 @@
 MP_ARGS_END
 
-        static void submit(function<void ()> func);    // FIXME
+        static void submit(function<void ()> func);
 
         static void join();
@@ -85 +85 @@
         blocking_vector<function<void ()> > m_messages;
         zone m_zone;
-
-        typedef std::vector<function<void ()> > messages_t;
 
 private:

lang/c/mpio/trunk/mp/iothreads_impl.pre.h

@@ -26 +26 @@
 
 template <typename ThreadIMPL>
-ThreadIMPL* manager::add_thread() {
+inline ThreadIMPL* manager::add_thread() {
         return instance().add_thread_impl<ThreadIMPL>();
 }
@@ -32 +32 @@
 MP_ARGS_BEGIN
 template <typename ThreadIMPL, MP_ARGS_TEMPLATE>
-ThreadIMPL* manager::add_thread(MP_ARGS_PARAMS) {
+inline ThreadIMPL* manager::add_thread(MP_ARGS_PARAMS) {
         return instance().add_thread_impl<ThreadIMPL>(MP_ARGS_FUNC);
 }

lang/c/mpio/trunk/mp/pthread.h

@@ -20 +20 @@
 #define MP_PTHREAD_H__
 
+#include "mp/exception.h"
 #include <pthread.h>
 #include <signal.h>
 
 namespace mp {
+
+
+struct pthread_error : system_error {
+        pthread_error(int errno_, const std::string& msg) :
+                system_error(errno_, msg) {}
+};
 
 
@@ -39 +46 @@
 private:
         pthread_t m_thread;
-        friend bool operator== (const pthread_thread& x, const pthread_thread& y);
+        bool operator== (const pthread_thread& other) const;
+        bool operator!= (const pthread_thread& other) const;
 };
-
-bool operator== (const pthread_thread& x, const pthread_thread& y);
 
 
@@ -102 +108 @@
 private:
         struct scoped_sigprocmask {
-                scoped_sigprocmask(const sigset_t& ss) : m_ss(ss)
-                        { sigprocmask(SIG_BLOCK, &m_ss, NULL); }
-                ~scoped_sigprocmask()
-                        { sigprocmask(SIG_UNBLOCK, &m_ss, NULL); }
+                scoped_sigprocmask(const sigset_t& ss);
+                ~scoped_sigprocmask();
                 const sigset_t* get() const { return &m_ss; }
         private:

lang/c/mpio/trunk/mp/pthread_impl.h

@@ -20 +20 @@
 #define MP_PTHREAD_IMPL_H__
 
+#include <iostream>
+#include <typeinfo>
+#ifndef MP_NO_CXX_ABI_H
+#include <cxxabi.h>
+#endif
+
 namespace mp {
 
@@ -26 +32 @@
 pthread_thread::pthread_thread(IMPL* pimpl)
 {
-        pthread_create(&m_thread, NULL,
+        int err = pthread_create(&m_thread, NULL,
                         &pthread_thread::trampoline<IMPL>,
-                        reinterpret_cast<void*>(pimpl)
-                        );
+                        reinterpret_cast<void*>(pimpl));
+        if(err) { throw pthread_error(err, "failed to create thread"); }
 }
 
@@ -37 +43 @@
 inline void pthread_thread::detach()
 {
-        pthread_detach(m_thread);
+        int err = pthread_detach(m_thread);
+        if(err) { throw pthread_error(err, "failed to detach thread"); }
 }
 
@@ -43 +50 @@
 {
         void* ret;
-        pthread_join(m_thread, &ret);  // FIXME error
+        int err = pthread_join(m_thread, &ret);
+        if(err) { throw pthread_error(err, "failed to join thread"); }
         return ret;
 }
 
-inline bool operator== (const pthread_thread& x, const pthread_thread& y)
+inline bool pthread_thread::operator== (const pthread_thread& other) const
 {
-        return pthread_equal(x.m_thread, y.m_thread);
+        return pthread_equal(m_thread, other.m_thread);
+}
+
+inline bool pthread_thread::operator!= (const pthread_thread& other) const
+{
+        return !(*this == other);
 }
 
 template <typename IMPL>
 void* pthread_thread::trampoline(void* obj)
-{
-        // FIXME exception
+try {
         reinterpret_cast<IMPL*>(obj)->operator()();
         return NULL;  // FIXME
+
+} catch (std::exception& e) {
+        try {
+#ifndef MP_NO_CXX_ABI_H
+                int status;
+                std::cerr
+                        << "thread terminated with throwing an instance of '"
+                        << abi::__cxa_demangle(typeid(e).name(), 0, 0, &status)
+                        << "'\n"
+                        << "  what():  " << e.what() << std::endl;
+#else
+                std::cerr
+                        << "thread terminated with throwing an instance of '"
+                        << typeid(e).name()
+                        << "'\n"
+                        << "  what():  " << e.what() << std::endl;
+#endif
+        } catch (...) {}
+        throw;
+
+} catch (...) {
+        try {
+                std::cerr << "thread terminated with throwing an unknown object" << std::endl;
+        } catch (...) {}
+        throw;
 }
 
@@ -118 +155 @@
 
 
+inline pthread_signal::scoped_sigprocmask::scoped_sigprocmask(const sigset_t& ss) :
+        m_ss(ss)
+{
+        if( sigprocmask(SIG_BLOCK, &m_ss, NULL) < 0 ) {
+                throw pthread_error(errno, "failed to set sigprocmask");
+        }
+}
+
+inline pthread_signal::scoped_sigprocmask::~scoped_sigprocmask()
+{
+        sigprocmask(SIG_UNBLOCK, &m_ss, NULL);
+}
+
 inline pthread_signal::pthread_signal(const sigset_t& ss, void (*handler)(int)) :
         m_sigmask(ss), m_handler(handler), m_thread(this) {}

lang/c/mpio/trunk/mp/system/buffered_kqueue_impl.h

@@ -7 +7 @@
 system::system() : m_kqfd(kqueue())
 {
-        // FIXME m_kqfd < 0
+        if(m_kqfd < 0) {
+                throw event_error(errno, "failed to initialize kqueue");
+        }
 }
 

lang/c/mpio/trunk/mp/system/epoll_impl.h

@@ -10 +10 @@
 system::system() : m_epfd(epoll_create(MP_EVENT_EPOLL_MAX_RESULT))
 {
-        // FIXME m_epfd < 0
+        if(m_epfd < 0) {
+                throw event_error(errno, "failed to create epoll");
+        }
 }
 

lang/c/mpio/trunk/mp/system/kqueue_impl.h

@@ -7 +7 @@
 system::system() : m_kqfd(kqueue())
 {
-        // FIXME m_kqfd < 0
+        if(m_kqfd < 0) {
+                throw event_error(errno, "failed to initialize kqueue");
+        }
 }
 

lang/c/mpio/trunk/mp/utility.pre.h

@@ -37 +37 @@
 inline void set_nonblock(int fd)
 {
-        // FIXME error
-        fcntl(fd, F_SETFL, O_NONBLOCK);
+        if( ::fcntl(fd, F_SETFL, O_NONBLOCK) < 0 ) {
+                throw system_error(errno, "failed to set nonblock flag");
+        }
 }
 
@@ -153 +154 @@
 
 #endif /* mp/utility.h */
+

lang/c/mpio/trunk/mp/zone_impl.pre.h

@@ -21 +21 @@
 
 #include <stdlib.h>
-#include <stdexcept>
+#include <new>
 
 namespace mp {

lang/c/mpio/trunk/src/iothreads.cc

@@ -46 +46 @@
 void manager::run_impl()
 {
+        typedef std::vector<function<void ()> > messages_t;
         messages_t cache;
         while(!m_end_flag) {

lang/c/mpio/trunk/src/iothreads_connector.cc

@@ -141 +141 @@
 connector::impl::worker::worker()
 {
-        m_ev.add(m_notify.getfd(), EV_READ);  // FIXME error
+        if( m_ev.add(m_notify.getfd(), EV_READ) < 0 ) {
+                throw event_error(errno, "iothreads connector failed to initialize event notifier");
+        }
 }
 
@@ -178 +180 @@
                 if(m_ev.wait(1000) < 0) {   // FIXME
                         if(errno != EAGAIN && errno != EINTR) {
-                                throw std::runtime_error("connector event failed");
+                                throw event_error(errno, "iothreads connector event failed");
                         }
                 }

lang/c/mpio/trunk/src/iothreads_listener.cc

@@ -118 +118 @@
 listener::impl::worker::worker()
 {
-        m_ev.add(m_notify.getfd(), EV_READ,
-                        (void (*)(void*, int))NULL, (void*)NULL);  // FIXME error
+        if( m_ev.add(m_notify.getfd(), EV_READ,
+                        (void (*)(void*, int))NULL, (void*)NULL) < 0 ) {
+                throw event_error(errno, "iothreads listener failed to initialize event notifier");
+        }
 }
 
@@ -150 +152 @@
                 if(m_ev.wait(1000) < 0) {   // FIXME
                         if(errno != EAGAIN && errno != EINTR) {
-                                throw std::runtime_error("listener event failed");
+                                throw event_error(errno, "iothreads listener event failed");
                         }
                 }
@@ -171 +173 @@
 void listener::impl::worker::listen_impl(notify_entry& e)
 {
-        m_ev.add(e.lsock, EV_READ, e.callback, e.obj);
+        if( m_ev.add(e.lsock, EV_READ, e.callback, e.obj) < 0 ) {
+                throw event_error(errno, "iothreads listener failed to add event");
+        }
 }
 

lang/c/mpio/trunk/src/iothreads_reader.cc

@@ -60 +60 @@
                                 message_t* func;
                                 int fd;
-                        } m;
+                        } message;
                 } as;
         };
@@ -130 +130 @@
 reader::impl::worker::worker()
 {
-        m_ev.add(m_notify.getfd(), EV_READ);  // FIXME error
+        if( m_ev.add(m_notify.getfd(), EV_READ) < 0 ) {
+                throw event_error(errno, "iothreads reader failed to initialize event notifier");
+        }
 }
 
@@ -153 +155 @@
 {
         notify_entry e = { MESSAGE };
-        e.as.m.func = msg;
-        e.as.m.fd = fd;
+        e.as.message.func = msg;
+        e.as.message.fd = fd;
         try {
                 m_notify.send(e);
@@ -170 +172 @@
                 if(m_ev.wait(1000) < 0) {   // FIXME
                         if(errno != EAGAIN && errno != EINTR) {
-                                throw std::runtime_error("reader event failed");
+                                throw event_error(errno, "iothreads reader event failed");
                         }
                 }
@@ -214 +216 @@
 
         } else {  // e.type == MESSAGE
-                int fd = e.as.m.fd;
+                int fd = e.as.message.fd;
+                std::auto_ptr<message_t> func(e.as.message.func);
                 if(!m_ev.test(fd)) { return; }
-                message_t* func = e.as.m.func;
-                try {
-                        (*func)(*m_ev.data(fd));
-                } catch (...) {
-                        delete func;
-                        throw;
+                (*func)(*m_ev.data(fd));
+        }
+}
+
+inline void reader::impl::worker::add_handler(handler* h)
+{
+        try {
+                if( m_ev.add(h->fd(), EV_READ, h) < 0 ) {
+                        throw event_error(errno, "iothreads reader failed to add event");
                 }
-                delete func;
-        }
-}
-
-inline void reader::impl::worker::add_handler(handler* h)
-{
-        try {
-                m_ev.add(h->fd(), EV_READ, h);
         } catch (...) {
                 ::close(h->fd());

lang/c/mpio/trunk/src/iothreads_writer.cc

@@ -185 +185 @@
                 struct rlimit rbuf;
                 if(::getrlimit(RLIMIT_NOFILE, &rbuf) < 0) {
-                        throw std::runtime_error("getrlimit() failed");
+                        throw system_error(errno, "getrlimit() failed");
                 }
 
@@ -386 +386 @@
 writer::impl::worker::worker()
 {
-        m_ev.add(m_notify.getfd(), EV_READ);  // FIXME error
+        if( m_ev.add(m_notify.getfd(), EV_READ) < 0 ) {
+                throw event_error(errno, "iothreads writer failed to initialize event notifier");
+        }
 }
 
@@ -414 +416 @@
                 if(m_ev.wait(1000) < 0) {   // FIXME
                         if(errno != EAGAIN && errno != EINTR) {
-                                throw std::runtime_error("writer event failed");
+                                throw event_error(errno, "iothreads writer event failed");
                         }
                 }
@@ -469 +471 @@
         impl::wake_io_ebit(e.fd);
         if(!m_ev.test(e.fd)) {
-                m_ev.add(e.fd, EV_WRITE);  // FIXME error
+                if( m_ev.add(e.fd, EV_WRITE) < 0 ) {
+                        throw event_error(errno, "iothreads writer failed to add event");
+                }
         }
         request req(e.buf, e.buflen, e.finalize, e.user, e.thread_safe);