← 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 Aker
  • Date: 2008-10-28 08:36:02 UTC
  • mfrom: (520.4.13 merge-innodb-plugin)
  • Revision ID: brian@tangent.org-20081028083602-0p3zzlhlxr5q2sqo
Merging Monty's work

Show diffs side-by-side

added added

removed removed

Lines of Context:
storage/innobase/ha/hash0hash.c
15
15
 
16
16
/****************************************************************
17
17
Reserves the mutex for a fold value in a hash table. */
18
 
 
 
18
UNIV_INTERN
19
19
void
20
20
hash_mutex_enter(
21
21
/*=============*/
27
27
 
28
28
/****************************************************************
29
29
Releases the mutex for a fold value in a hash table. */
30
 
 
 
30
UNIV_INTERN
31
31
void
32
32
hash_mutex_exit(
33
33
/*============*/
39
39
 
40
40
/****************************************************************
41
41
Reserves all the mutexes of a hash table, in an ascending order. */
42
 
 
 
42
UNIV_INTERN
43
43
void
44
44
hash_mutex_enter_all(
45
45
/*=================*/
55
55
 
56
56
/****************************************************************
57
57
Releases all the mutexes of a hash table. */
58
 
 
 
58
UNIV_INTERN
59
59
void
60
60
hash_mutex_exit_all(
61
61
/*================*/
72
72
/*****************************************************************
73
73
Creates a hash table with >= n array cells. The actual number of cells is
74
74
chosen to be a prime number slightly bigger than n. */
75
 
 
 
75
UNIV_INTERN
76
76
hash_table_t*
77
77
hash_create(
78
78
/*========*/
82
82
        hash_cell_t*    array;
83
83
        ulint           prime;
84
84
        hash_table_t*   table;
85
 
        ulint           i;
86
 
        hash_cell_t*    cell;
87
85
 
88
86
        prime = ut_find_prime(n);
89
87
 
91
89
 
92
90
        array = ut_malloc(sizeof(hash_cell_t) * prime);
93
91
 
 
92
#ifdef UNIV_DEBUG
94
93
        table->adaptive = FALSE;
 
94
#endif /* UNIV_DEBUG */
95
95
        table->array = array;
96
96
        table->n_cells = prime;
97
97
        table->n_mutexes = 0;
101
101
        table->magic_n = HASH_TABLE_MAGIC_N;
102
102
 
103
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
 
        }
 
104
        hash_table_clear(table);
110
105
 
111
106
        return(table);
112
107
}
113
108
 
114
109
/*****************************************************************
115
110
Frees a hash table. */
116
 
 
 
111
UNIV_INTERN
117
112
void
118
113
hash_table_free(
119
114
/*============*/
127
122
 
128
123
/*****************************************************************
129
124
Creates a mutex array to protect a hash table. */
130
 
 
 
125
UNIV_INTERN
131
126
void
132
127
hash_create_mutexes_func(
133
128
/*=====================*/
141
136
{
142
137
        ulint   i;
143
138
 
144
 
        ut_a(n_mutexes == ut_2_power_up(n_mutexes));
 
139
        ut_a(n_mutexes > 0);
 
140
        ut_a(ut_is_2pow(n_mutexes));
145
141
 
146
142
        table->mutexes = mem_alloc(n_mutexes * sizeof(mutex_t));
147
143