--- /dev/null
+/* -*- c++ -*- */
+/*
+ * Copyright 2007,2008 Free Software Foundation, Inc.
+ *
+ * This file is part of GNU Radio
+ *
+ * GNU Radio is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3, or (at your option)
+ * any later version.
+ *
+ * GNU Radio is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include <mb_worker.h>
+#include <mb_runtime_thread_per_block.h>
+#include <mblock/exception.h>
+#include <mblock/mblock.h>
+#include <mb_gettid.h>
+#include <mblock/msg_accepter.h>
+#include <iostream>
+#include <cstdio>
+#ifdef HAVE_SCHED_H
+#include <sched.h>
+#endif
+
+#define VERBOSE 0 // define to 0 or 1
+
+
+static pmt_t s_worker_state_changed = pmt_intern("%worker-state-changed");
+
+
+mb_worker::mb_worker(mb_runtime_thread_per_block *runtime,
+ mb_mblock_maker_t maker,
+ const std::string &instance_name,
+ pmt_t user_arg)
+ : omni_thread((void *) 0, PRIORITY_NORMAL),
+ d_runtime(runtime), d_maker(maker),
+ d_instance_name(instance_name), d_user_arg(user_arg),
+ d_state_cond(&d_mutex), d_state(TS_UNINITIALIZED),
+ d_why_dead(RIP_NOT_DEAD_YET)
+{
+}
+
+#if 0
+mb_worker::~mb_worker()
+{
+}
+#endif
+
+#ifdef HAVE_SCHED_SETAFFINITY
+static void
+set_affinity(const std::string &instance_name, const std::string &class_name)
+{
+ //static int counter = 0;
+ cpu_set_t mask;
+ CPU_ZERO(&mask);
+
+ if (0){
+
+ //CPU_SET(counter & 0x1, &mask);
+ //counter++;
+ CPU_SET(0, &mask);
+
+ int r = sched_setaffinity(mb_gettid(), sizeof(mask), &mask);
+ if (r == -1)
+ perror("sched_setaffinity");
+ }
+}
+#else
+static void
+set_affinity(const std::string &instance_name, const std::string &class_name)
+{
+}
+#endif
+
+void
+mb_worker::set_state(worker_state_t state)
+{
+ {
+ omni_mutex_lock l2(d_mutex);
+
+ d_state = state; // update our state
+ d_state_cond.broadcast(); // Notify everybody who cares...
+ }
+
+ // send msg to runtime, telling it something changed.
+ (*d_runtime->accepter())(s_worker_state_changed, PMT_F, PMT_F, MB_PRI_BEST);
+}
+
+void *
+mb_worker::run_undetached(void *ignored)
+{
+ // FIXME add pthread_sigmask stuff
+
+ //set_affinity(d_instance_name, d_class_name);
+ set_affinity(d_instance_name, "");
+
+ try {
+ worker_thread_top_level();
+ d_why_dead = RIP_EXIT;
+ }
+ catch (mbe_terminate){
+ d_why_dead = RIP_TERMINATE;
+ }
+ catch (mbe_exit){
+ d_why_dead = RIP_EXIT;
+ }
+ catch (std::logic_error e){
+ if (d_why_dead == RIP_NOT_DEAD_YET)
+ d_why_dead = RIP_UNHANDLED_EXCEPTION;
+
+ std::cerr << "\nmb_worker::run_undetached: unhandled exception:\n";
+ std::cerr << " " << e.what() << std::endl;
+ }
+ catch (...){
+ if (d_why_dead == RIP_NOT_DEAD_YET)
+ d_why_dead = RIP_UNHANDLED_EXCEPTION;
+ }
+
+ if (VERBOSE)
+ std::cerr << "\nrun_undetached: about to return, d_why_dead = "
+ << d_why_dead << std::endl;
+
+ set_state(TS_DEAD);
+ return 0;
+}
+
+void
+mb_worker::worker_thread_top_level()
+{
+ if (VERBOSE)
+ std::cerr << "worker_thread_top_level (enter):" << std::endl
+ << " instance_name: " << d_instance_name << std::endl
+ << " omnithread id: " << id() << std::endl
+ << " gettid: " << mb_gettid() << std::endl
+ << " getpid: " << getpid() << std::endl;
+
+ cause_of_death_t pending_cause_of_death = RIP_NOT_DEAD_YET;
+
+ try {
+ pending_cause_of_death = RIP_CTOR_EXCEPTION;
+ d_mblock = d_maker(d_runtime, d_instance_name, d_user_arg);
+
+ if (VERBOSE)
+ std::cerr << "worker_thread_top_level (post-construction):" << std::endl
+ << " instance_name: " << d_instance_name << std::endl;
+
+ pending_cause_of_death = RIP_INIT_EXCEPTION;
+ d_mblock->initial_transition();
+
+ if (VERBOSE)
+ std::cerr << "worker_thread_top_level (post-initial-transition):" << std::endl
+ << " instance_name: " << d_instance_name << std::endl;
+
+ set_state(TS_RUNNING);
+
+ pending_cause_of_death = RIP_UNHANDLED_EXCEPTION;
+ d_mblock->main_loop();
+ }
+ catch (...){
+ d_why_dead = pending_cause_of_death;
+ throw;
+ }
+
+ if (VERBOSE)
+ std::cerr << "worker_thread_top_level (exit):" << std::endl
+ << " instance_name: " << d_instance_name << std::endl;
+}