← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to plugin/multi_thread/multi_thread.cc

Merged plugin-registration.

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/multi_thread/multi_thread.cc
23
23
#include <drizzled/session.h>
24
24
#include <drizzled/connect.h>
25
25
#include <string>
 
26
 
26
27
using namespace std;
27
28
 
28
 
pthread_attr_t multi_thread_attrib;
29
29
static uint32_t max_threads;
30
 
static tbb::atomic<uint32_t> thread_count;
31
 
 
32
 
static bool add_connection(Session *session)
33
 
{
34
 
  int error;
35
 
 
36
 
  thread_count++;
37
 
 
38
 
  if ((error= pthread_create(&session->real_id, &multi_thread_attrib, handle_one_connection, (void*) session)))
39
 
    return true;
40
 
 
41
 
  return false;
42
 
}
43
 
 
44
 
 
45
 
/*
46
 
  End connection, in case when we are using 'no-threads'
47
 
*/
48
 
 
49
 
static bool end_thread(Session *session, bool)
50
 
{
51
 
  unlink_session(session);   /* locks LOCK_thread_count and deletes session */
52
 
  thread_count--;
53
 
 
54
 
  my_thread_end();
55
 
  pthread_exit(0);
56
 
 
57
 
  return true; // We should never reach this point
58
 
}
59
 
 
60
 
static uint32_t count_of_threads(void)
61
 
{
62
 
  return thread_count;
63
 
}
 
30
 
 
31
class Multi_thread_scheduler: public Scheduler
 
32
{
 
33
  tbb::atomic<uint32_t> thread_count;
 
34
  pthread_attr_t multi_thread_attrib;
 
35
 
 
36
public:
 
37
  Multi_thread_scheduler(uint32_t threads): Scheduler(threads)
 
38
  {
 
39
    thread_count= 0;
 
40
    /* Parameter for threads created for connections */
 
41
    (void) pthread_attr_init(&multi_thread_attrib);
 
42
    (void) pthread_attr_setdetachstate(&multi_thread_attrib,
 
43
                                       PTHREAD_CREATE_DETACHED);
 
44
    pthread_attr_setscope(&multi_thread_attrib, PTHREAD_SCOPE_SYSTEM);
 
45
    {
 
46
      struct sched_param tmp_sched_param;
 
47
  
 
48
      memset(&tmp_sched_param, 0, sizeof(tmp_sched_param));
 
49
      tmp_sched_param.sched_priority= WAIT_PRIOR;
 
50
      (void)pthread_attr_setschedparam(&multi_thread_attrib, &tmp_sched_param);
 
51
    }
 
52
  }
 
53
 
 
54
  ~Multi_thread_scheduler()
 
55
  {
 
56
    (void) pthread_mutex_lock(&LOCK_thread_count);
 
57
    while (thread_count)
 
58
    {
 
59
      pthread_cond_wait(&COND_thread_count, &LOCK_thread_count);
 
60
    }
 
61
    (void) pthread_mutex_unlock(&LOCK_thread_count);
 
62
    
 
63
    pthread_attr_destroy(&multi_thread_attrib);
 
64
  }
 
65
 
 
66
  virtual bool add_connection(Session *session)
 
67
  {
 
68
    int error;
 
69
  
 
70
    thread_count++;
 
71
  
 
72
    if ((error= pthread_create(&session->real_id, &multi_thread_attrib, handle_one_connection, static_cast<void*>(session))))
 
73
      return true;
 
74
  
 
75
    return false;
 
76
  }
 
77
  
 
78
  
 
79
  /*
 
80
    End connection, in case when we are using 'no-threads'
 
81
  */
 
82
  
 
83
  virtual bool end_thread(Session *session, bool)
 
84
  {
 
85
    unlink_session(session);   /* locks LOCK_thread_count and deletes session */
 
86
    thread_count--;
 
87
  
 
88
    my_thread_end();
 
89
    pthread_exit(0);
 
90
  
 
91
    return true; // We should never reach this point
 
92
  }
 
93
  
 
94
  virtual uint32_t count(void)
 
95
  {
 
96
    return thread_count;
 
97
  }
 
98
};
64
99
 
65
100
static int init(void *p)
66
101
{
67
 
  scheduling_st* func= (scheduling_st *)p;
68
 
 
69
 
  func->max_threads= max_threads; /* This will create an upper limit on max connections */
70
 
  func->add_connection= add_connection;
71
 
  func->end_thread= end_thread;
72
 
  func->count= count_of_threads;
73
 
 
74
 
  /* Parameter for threads created for connections */
75
 
  (void) pthread_attr_init(&multi_thread_attrib);
76
 
  (void) pthread_attr_setdetachstate(&multi_thread_attrib,
77
 
                                     PTHREAD_CREATE_DETACHED);
78
 
  pthread_attr_setscope(&multi_thread_attrib, PTHREAD_SCOPE_SYSTEM);
79
 
  {
80
 
    struct sched_param tmp_sched_param;
81
 
 
82
 
    memset(&tmp_sched_param, 0, sizeof(tmp_sched_param));
83
 
    tmp_sched_param.sched_priority= WAIT_PRIOR;
84
 
    (void)pthread_attr_setschedparam(&multi_thread_attrib, &tmp_sched_param);
85
 
  }
 
102
  Multi_thread_scheduler** sched= static_cast<Multi_thread_scheduler **>(p);
 
103
 
 
104
  *sched= new Multi_thread_scheduler(max_threads);
86
105
 
87
106
  return 0;
88
107
}
89
108
 
90
 
static int deinit(void *)
 
109
static int deinit(void *p)
91
110
{
92
 
  (void) pthread_mutex_lock(&LOCK_thread_count);
93
 
  while (thread_count)
94
 
  {
95
 
    pthread_cond_wait(&COND_thread_count, &LOCK_thread_count);
96
 
  }
97
 
  (void) pthread_mutex_unlock(&LOCK_thread_count);
98
111
 
99
 
  pthread_attr_destroy(&multi_thread_attrib);
 
112
  Multi_thread_scheduler *sched= static_cast<Multi_thread_scheduler *>(p);
 
113
  delete sched;
100
114
 
101
115
  return 0;
102
116
}
117
131
  "multi_thread",
118
132
  "0.1",
119
133
  "Brian Aker",
120
 
  "One Thread Perl Session Scheduler",
 
134
  "One Thread Per Session Scheduler",
121
135
  PLUGIN_LICENSE_GPL,
122
136
  init, /* Plugin Init */
123
137
  deinit, /* Plugin Deinit */