← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to storage/innobase/ha/hash0hash.c

  • Committer: brian
  • Date: 2008-06-25 05:29:13 UTC
  • Revision ID: brian@localhost.localdomain-20080625052913-6upwo0jsrl4lnapl
clean slate

Show diffs side-by-side

added added

removed removed

Lines of Context:
storage/innobase/ha/hash0hash.c
 
1
/******************************************************
 
2
The simple hash table utility
 
3
 
 
4
(c) 1997 Innobase Oy
 
5
 
 
6
Created 5/20/1997 Heikki Tuuri
 
7
*******************************************************/
 
8
 
 
9
#include "hash0hash.h"
 
10
#ifdef UNIV_NONINL
 
11
#include "hash0hash.ic"
 
12
#endif
 
13
 
 
14
#include "mem0mem.h"
 
15
 
 
16
/****************************************************************
 
17
Reserves the mutex for a fold value in a hash table. */
 
18
 
 
19
void
 
20
hash_mutex_enter(
 
21
/*=============*/
 
22
        hash_table_t*   table,  /* in: hash table */
 
23
        ulint           fold)   /* in: fold */
 
24
{
 
25
        mutex_enter(hash_get_mutex(table, fold));
 
26
}
 
27
 
 
28
/****************************************************************
 
29
Releases the mutex for a fold value in a hash table. */
 
30
 
 
31
void
 
32
hash_mutex_exit(
 
33
/*============*/
 
34
        hash_table_t*   table,  /* in: hash table */
 
35
        ulint           fold)   /* in: fold */
 
36
{
 
37
        mutex_exit(hash_get_mutex(table, fold));
 
38
}
 
39
 
 
40
/****************************************************************
 
41
Reserves all the mutexes of a hash table, in an ascending order. */
 
42
 
 
43
void
 
44
hash_mutex_enter_all(
 
45
/*=================*/
 
46
        hash_table_t*   table)  /* in: hash table */
 
47
{
 
48
        ulint   i;
 
49
 
 
50
        for (i = 0; i < table->n_mutexes; i++) {
 
51
 
 
52
                mutex_enter(table->mutexes + i);
 
53
        }
 
54
}
 
55
 
 
56
/****************************************************************
 
57
Releases all the mutexes of a hash table. */
 
58
 
 
59
void
 
60
hash_mutex_exit_all(
 
61
/*================*/
 
62
        hash_table_t*   table)  /* in: hash table */
 
63
{
 
64
        ulint   i;
 
65
 
 
66
        for (i = 0; i < table->n_mutexes; i++) {
 
67
 
 
68
                mutex_exit(table->mutexes + i);
 
69
        }
 
70
}
 
71
 
 
72
/*****************************************************************
 
73
Creates a hash table with >= n array cells. The actual number of cells is
 
74
chosen to be a prime number slightly bigger than n. */
 
75
 
 
76
hash_table_t*
 
77
hash_create(
 
78
/*========*/
 
79
                        /* out, own: created table */
 
80
        ulint   n)      /* in: number of array cells */
 
81
{
 
82
        hash_cell_t*    array;
 
83
        ulint           prime;
 
84
        hash_table_t*   table;
 
85
        ulint           i;
 
86
        hash_cell_t*    cell;
 
87
 
 
88
        prime = ut_find_prime(n);
 
89
 
 
90
        table = mem_alloc(sizeof(hash_table_t));
 
91
 
 
92
        array = ut_malloc(sizeof(hash_cell_t) * prime);
 
93
 
 
94
        table->adaptive = FALSE;
 
95
        table->array = array;
 
96
        table->n_cells = prime;
 
97
        table->n_mutexes = 0;
 
98
        table->mutexes = NULL;
 
99
        table->heaps = NULL;
 
100
        table->heap = NULL;
 
101
        table->magic_n = HASH_TABLE_MAGIC_N;
 
102
 
 
103
        /* Initialize the cell array */
 
104
 
 
105
        for (i = 0; i < prime; i++) {
 
106
 
 
107
                cell = hash_get_nth_cell(table, i);
 
108
                cell->node = NULL;
 
109
        }
 
110
 
 
111
        return(table);
 
112
}
 
113
 
 
114
/*****************************************************************
 
115
Frees a hash table. */
 
116
 
 
117
void
 
118
hash_table_free(
 
119
/*============*/
 
120
        hash_table_t*   table)  /* in, own: hash table */
 
121
{
 
122
        ut_a(table->mutexes == NULL);
 
123
 
 
124
        ut_free(table->array);
 
125
        mem_free(table);
 
126
}
 
127
 
 
128
/*****************************************************************
 
129
Creates a mutex array to protect a hash table. */
 
130
 
 
131
void
 
132
hash_create_mutexes_func(
 
133
/*=====================*/
 
134
        hash_table_t*   table,          /* in: hash table */
 
135
#ifdef UNIV_SYNC_DEBUG
 
136
        ulint           sync_level,     /* in: latching order level of the
 
137
                                        mutexes: used in the debug version */
 
138
#endif /* UNIV_SYNC_DEBUG */
 
139
        ulint           n_mutexes)      /* in: number of mutexes, must be a
 
140
                                        power of 2 */
 
141
{
 
142
        ulint   i;
 
143
 
 
144
        ut_a(n_mutexes == ut_2_power_up(n_mutexes));
 
145
 
 
146
        table->mutexes = mem_alloc(n_mutexes * sizeof(mutex_t));
 
147
 
 
148
        for (i = 0; i < n_mutexes; i++) {
 
149
                mutex_create(table->mutexes + i, sync_level);
 
150
        }
 
151
 
 
152
        table->n_mutexes = n_mutexes;
 
153
}