← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to plugin/single_thread/single_thread.cc

Merged plugin-registration.

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/single_thread/single_thread.cc
25
25
#include <string>
26
26
using namespace std;
27
27
 
28
 
static bool init_new_connection_thread(void) {return 0;}
29
 
 
30
 
/*
31
 
  Simple scheduler that use the main thread to handle the request
32
 
 
33
 
  NOTES
34
 
  This is only used for debugging, when starting mysqld with
35
 
  --thread-handling=no-threads or --one-thread
36
 
 
37
 
  When we enter this function, LOCK_thread_count is held!
38
 
*/
39
 
 
40
 
bool add_connection(Session *session)
41
 
{
42
 
  handle_one_connection((void*) session);
43
 
 
44
 
  return false;
45
 
}
46
 
 
47
 
 
48
 
/*
49
 
  End connection, in case when we are using 'no-threads'
50
 
*/
51
 
 
52
 
static bool end_thread(Session *session, bool)
53
 
{
54
 
  unlink_session(session);   /* locks LOCK_thread_count and deletes session */
55
 
 
56
 
  return true;                                     // Abort handle_one_connection
57
 
}
58
 
 
59
 
 
60
 
static uint32_t count_of_threads(void)
61
 
{
62
 
  return 0;
63
 
}
64
 
 
 
28
class Single_thread_scheduler : public Scheduler
 
29
{
 
30
public:
 
31
  Single_thread_scheduler(uint32_t threads): Scheduler(threads) {}
 
32
 
 
33
  virtual bool init_new_connection_thread(void) {return 0;}
 
34
  
 
35
  /*
 
36
    Simple scheduler that use the main thread to handle the request
 
37
  
 
38
    NOTES
 
39
    This is only used for debugging, when starting mysqld with
 
40
    --thread-handling=no-threads or --one-thread
 
41
  
 
42
    When we enter this function, LOCK_thread_count is held!
 
43
  */
 
44
  
 
45
  virtual bool add_connection(Session *session)
 
46
  {
 
47
    handle_one_connection((void*) session);
 
48
  
 
49
    return false;
 
50
  }
 
51
  
 
52
  
 
53
  /*
 
54
    End connection, in case when we are using 'no-threads'
 
55
  */
 
56
  
 
57
  virtual bool end_thread(Session *session, bool)
 
58
  {
 
59
    unlink_session(session);   /* locks LOCK_thread_count and deletes session */
 
60
  
 
61
    return true;                                     // Abort handle_one_connection
 
62
  }
 
63
  
 
64
  
 
65
  virtual uint32_t count(void)
 
66
  {
 
67
    return 0;
 
68
  }
 
69
  
 
70
};
65
71
 
66
72
static int init(void *p)
67
73
{
68
 
  scheduling_st* func= (scheduling_st *)p;
69
 
 
70
 
  func->max_threads= 1;
71
 
  func->add_connection= add_connection;
72
 
  func->init_new_connection_thread= init_new_connection_thread;
73
 
  func->end_thread= end_thread;
74
 
  func->count= count_of_threads;
 
74
  Scheduler **sched= static_cast<Scheduler **>(p);
 
75
  *sched= new Single_thread_scheduler(1);
75
76
 
76
77
  return 0;
77
78
}
78
79
 
79
 
static int deinit(void *)
 
80
static int deinit(void *p)
80
81
{
 
82
  Scheduler *sched= static_cast<Scheduler *>(p);
 
83
  delete sched;
81
84
  return 0;
82
85
}
83
86