← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to plugin/multi_thread/multi_thread.cc

  • Committer: Brian Aker
  • Date: 2011-02-22 06:12:02 UTC
  • mfrom: (2190.1.6 drizzle-build)
  • Revision ID: brian@tangent.org-20110222061202-k03czxykqy4x9hjs
List update, header fixes, multiple symbols, and David deletes some code.

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/multi_thread/multi_thread.cc
 
1
/* Copyright (C) 2006 MySQL AB
 
2
 
 
3
   This program is free software; you can redistribute it and/or modify
 
4
   it under the terms of the GNU General Public License as published by
 
5
   the Free Software Foundation; version 2 of the License.
 
6
 
 
7
   This program is distributed in the hope that it will be useful,
 
8
   but WITHOUT ANY WARRANTY; without even the implied warranty of
 
9
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
10
   GNU General Public License for more details.
 
11
 
 
12
   You should have received a copy of the GNU General Public License
 
13
   along with this program; if not, write to the Free Software
 
14
   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA */
 
15
 
 
16
#include <config.h>
 
17
 
 
18
#include <iostream>
 
19
 
 
20
#include <drizzled/pthread_globals.h>
 
21
#include <drizzled/module/option_map.h>
 
22
#include <drizzled/errmsg_print.h>
 
23
#include <drizzled/session.h>
 
24
#include <drizzled/session/cache.h>
 
25
#include <drizzled/abort_exception.h>
 
26
#include <drizzled/transaction_services.h>
 
27
#include <drizzled/gettext.h>
 
28
 
 
29
#include <boost/thread.hpp>
 
30
#include <boost/bind.hpp>
 
31
#include <boost/program_options.hpp>
 
32
 
 
33
#include "multi_thread.h"
 
34
 
 
35
namespace po= boost::program_options;
 
36
using namespace std;
 
37
using namespace drizzled;
 
38
 
 
39
/* Configuration variables. */
 
40
typedef constrained_check<uint32_t, 4096, 1> max_threads_constraint;
 
41
static max_threads_constraint max_threads;
 
42
 
 
43
namespace drizzled
 
44
{
 
45
  extern size_t my_thread_stack_size;
 
46
}
 
47
 
 
48
namespace multi_thread {
 
49
 
 
50
void MultiThreadScheduler::runSession(drizzled::session_id_t id)
 
51
{
 
52
  char stack_dummy;
 
53
  boost::this_thread::disable_interruption disable_by_default;
 
54
 
 
55
  Session::shared_ptr session(session::Cache::singleton().find(id));
 
56
 
 
57
  try
 
58
  {
 
59
 
 
60
    if (not session)
 
61
    {
 
62
      std::cerr << _("Session killed before thread could execute") << endl;
 
63
      return;
 
64
    }
 
65
    session->pushInterrupt(&disable_by_default);
 
66
 
 
67
    if (drizzled::internal::my_thread_init())
 
68
    {
 
69
      session->disconnect(drizzled::ER_OUT_OF_RESOURCES);
 
70
      session->status_var.aborted_connects++;
 
71
    }
 
72
    else
 
73
    {
 
74
      boost::this_thread::at_thread_exit(&internal::my_thread_end);
 
75
 
 
76
      session->thread_stack= (char*) &stack_dummy;
 
77
      session->run();
 
78
    }
 
79
 
 
80
    killSessionNow(session);
 
81
  }
 
82
  catch (abort_exception& ex)
 
83
  {
 
84
    cout << _("Drizzle has receieved an abort event.") << endl;
 
85
    cout << _("In Function: ") << *::boost::get_error_info<boost::throw_function>(ex) << endl;
 
86
    cout << _("In File: ") << *::boost::get_error_info<boost::throw_file>(ex) << endl;
 
87
    cout << _("On Line: ") << *::boost::get_error_info<boost::throw_line>(ex) << endl;
 
88
 
 
89
    TransactionServices::singleton().sendShutdownEvent(*session.get());
 
90
  }
 
91
  // @todo remove hard spin by disconnection the session first from the
 
92
  // thread.
 
93
  while (not session.unique()) {}
 
94
}
 
95
 
 
96
void MultiThreadScheduler::setStackSize()
 
97
{
 
98
  pthread_attr_t attr;
 
99
 
 
100
  (void) pthread_attr_init(&attr);
 
101
 
 
102
  /* Get the thread stack size that the OS will use and make sure
 
103
    that we update our global variable. */
 
104
  int err= pthread_attr_getstacksize(&attr, &my_thread_stack_size);
 
105
  pthread_attr_destroy(&attr);
 
106
 
 
107
  if (err != 0)
 
108
  {
 
109
    errmsg_printf(error::ERROR, _("Unable to get thread stack size"));
 
110
    my_thread_stack_size= 524288; // At the time of the writing of this code, this was OSX's
 
111
  }
 
112
 
 
113
  if (my_thread_stack_size == 0)
 
114
  {
 
115
    my_thread_stack_size= 524288; // At the time of the writing of this code, this was OSX's
 
116
  }
 
117
#ifdef __sun
 
118
  /*
 
119
   * Solaris will return zero for the stack size in a call to
 
120
   * pthread_attr_getstacksize() to indicate that the OS default stack
 
121
   * size is used. We need an actual value in my_thread_stack_size so that
 
122
   * check_stack_overrun() will work. The Solaris man page for the
 
123
   * pthread_attr_getstacksize() function says that 2M is used for 64-bit
 
124
   * processes. We'll explicitly set it here to make sure that is what
 
125
   * will be used.
 
126
   */
 
127
  if (my_thread_stack_size == 0)
 
128
  {
 
129
    my_thread_stack_size= 2 * 1024 * 1024;
 
130
  }
 
131
#endif
 
132
}
 
133
 
 
134
bool MultiThreadScheduler::addSession(Session::shared_ptr &session)
 
135
{
 
136
  if (thread_count >= max_threads)
 
137
    return true;
 
138
 
 
139
  thread_count.increment();
 
140
  try
 
141
  {
 
142
    session->getThread().reset(new boost::thread((boost::bind(&MultiThreadScheduler::runSession, this, session->getSessionId()))));
 
143
  }
 
144
  catch (std::exception&)
 
145
  {
 
146
    thread_count.decrement();
 
147
    return true;
 
148
  }
 
149
 
 
150
  if (not session->getThread())
 
151
  {
 
152
    thread_count.decrement();
 
153
    return true;
 
154
  }
 
155
 
 
156
  if (not session->getThread()->joinable())
 
157
  {
 
158
    thread_count.decrement();
 
159
    return true;
 
160
  }
 
161
 
 
162
  return false;
 
163
}
 
164
 
 
165
 
 
166
void MultiThreadScheduler::killSession(Session *session)
 
167
{
 
168
  boost_thread_shared_ptr thread(session->getThread());
 
169
 
 
170
  if (thread)
 
171
  {
 
172
    thread->interrupt();
 
173
  }
 
174
}
 
175
 
 
176
void MultiThreadScheduler::killSessionNow(Session::shared_ptr &session)
 
177
{
 
178
  killSession(session.get());
 
179
 
 
180
  session->disconnect();
 
181
 
 
182
  /* Locks LOCK_thread_count and deletes session */
 
183
  Session::unlink(session);
 
184
  thread_count.decrement();
 
185
}
 
186
 
 
187
MultiThreadScheduler::~MultiThreadScheduler()
 
188
{
 
189
  boost::mutex::scoped_lock scopedLock(drizzled::session::Cache::singleton().mutex());
 
190
  while (thread_count)
 
191
  {
 
192
    COND_thread_count.wait(scopedLock);
 
193
  }
 
194
}
 
195
 
 
196
} // multi_thread namespace
 
197
 
 
198
  
 
199
static int init(drizzled::module::Context &context)
 
200
{
 
201
  
 
202
  context.add(new multi_thread::MultiThreadScheduler("multi_thread"));
 
203
 
 
204
  return 0;
 
205
}
 
206
 
 
207
static void init_options(drizzled::module::option_context &context)
 
208
{
 
209
  context("max-threads",
 
210
          po::value<max_threads_constraint>(&max_threads)->default_value(2048),
 
211
          _("Maximum number of user threads available."));
 
212
}
 
213
 
 
214
DRIZZLE_DECLARE_PLUGIN
 
215
{
 
216
  DRIZZLE_VERSION_ID,
 
217
  "multi_thread",
 
218
  "0.1",
 
219
  "Brian Aker",
 
220
  "One Thread Per Session Scheduler",
 
221
  PLUGIN_LICENSE_GPL,
 
222
  init, /* Plugin Init */
 
223
  NULL,   /* depends */
 
224
  init_options    /* config options */
 
225
}
 
226
DRIZZLE_DECLARE_PLUGIN_END;