← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to storage/innobase/srv/srv0que.c

  • Committer: Brian Aker
  • Date: 2009-01-24 09:43:35 UTC
  • Revision ID: brian@gir-3.local-20090124094335-6qdtvc35gl5fvivz
Adding in an example singe thread scheduler

Show diffs side-by-side

added added

removed removed

Lines of Context:
storage/innobase/srv/srv0que.c
1
 
/*****************************************************************************
2
 
 
3
 
Copyright (c) 1996, 2009, Innobase Oy. All Rights Reserved.
4
 
 
5
 
This program is free software; you can redistribute it and/or modify it under
6
 
the terms of the GNU General Public License as published by the Free Software
7
 
Foundation; version 2 of the License.
8
 
 
9
 
This program is distributed in the hope that it will be useful, but WITHOUT
10
 
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
11
 
FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
12
 
 
13
 
You should have received a copy of the GNU General Public License along with
14
 
this program; if not, write to the Free Software Foundation, Inc., 59 Temple
15
 
Place, Suite 330, Boston, MA 02111-1307 USA
16
 
 
17
 
*****************************************************************************/
18
 
 
19
 
/**************************************************//**
20
 
@file srv/srv0que.c
 
1
/******************************************************
21
2
Server query execution
22
3
 
 
4
(c) 1996 Innobase Oy
 
5
 
23
6
Created 6/5/1996 Heikki Tuuri
24
7
*******************************************************/
25
8
 
31
14
#include "usr0sess.h"
32
15
#include "que0que.h"
33
16
 
34
 
/**********************************************************************//**
 
17
/**************************************************************************
 
18
Checks if there is work to do in the server task queue. If there is, the
 
19
thread starts processing a task. Before leaving, it again checks the task
 
20
queue and picks a new task if any exists. This is called by a SRV_WORKER
 
21
thread. */
 
22
UNIV_INTERN
 
23
void
 
24
srv_que_task_queue_check(void)
 
25
/*==========================*/
 
26
{
 
27
        que_thr_t*      thr;
 
28
 
 
29
        for (;;) {
 
30
                mutex_enter(&kernel_mutex);
 
31
 
 
32
                thr = UT_LIST_GET_FIRST(srv_sys->tasks);
 
33
 
 
34
                if (thr == NULL) {
 
35
                        mutex_exit(&kernel_mutex);
 
36
 
 
37
                        return;
 
38
                }
 
39
 
 
40
                UT_LIST_REMOVE(queue, srv_sys->tasks, thr);
 
41
 
 
42
                mutex_exit(&kernel_mutex);
 
43
 
 
44
                que_run_threads(thr);
 
45
        }
 
46
}
 
47
 
 
48
/**************************************************************************
 
49
Performs round-robin on the server tasks. This is called by a SRV_WORKER
 
50
thread every second or so. */
 
51
UNIV_INTERN
 
52
que_thr_t*
 
53
srv_que_round_robin(
 
54
/*================*/
 
55
                                /* out: the new (may be == thr) query thread
 
56
                                to run */
 
57
        que_thr_t*      thr)    /* in: query thread */
 
58
{
 
59
        que_thr_t*      new_thr;
 
60
 
 
61
        ut_ad(thr);
 
62
        ut_ad(thr->state == QUE_THR_RUNNING);
 
63
 
 
64
        mutex_enter(&kernel_mutex);
 
65
 
 
66
        UT_LIST_ADD_LAST(queue, srv_sys->tasks, thr);
 
67
 
 
68
        new_thr = UT_LIST_GET_FIRST(srv_sys->tasks);
 
69
 
 
70
        mutex_exit(&kernel_mutex);
 
71
 
 
72
        return(new_thr);
 
73
}
 
74
 
 
75
/**************************************************************************
35
76
Enqueues a task to server task queue and releases a worker thread, if there
36
77
is a suspended one. */
37
78
UNIV_INTERN
38
79
void
39
80
srv_que_task_enqueue_low(
40
81
/*=====================*/
41
 
        que_thr_t*      thr)    /*!< in: query thread */
 
82
        que_thr_t*      thr)    /* in: query thread */
42
83
{
43
84
        ut_ad(thr);
44
85
        ut_ad(mutex_own(&kernel_mutex));
47
88
 
48
89
        srv_release_threads(SRV_WORKER, 1);
49
90
}
 
91
 
 
92
/**************************************************************************
 
93
Enqueues a task to server task queue and releases a worker thread, if there
 
94
is a suspended one. */
 
95
UNIV_INTERN
 
96
void
 
97
srv_que_task_enqueue(
 
98
/*=================*/
 
99
        que_thr_t*      thr)    /* in: query thread */
 
100
{
 
101
        ut_ad(thr);
 
102
 
 
103
        ut_a(0);        /* Under MySQL this is never called */
 
104
 
 
105
        mutex_enter(&kernel_mutex);
 
106
 
 
107
        srv_que_task_enqueue_low(thr);
 
108
 
 
109
        mutex_exit(&kernel_mutex);
 
110
}