← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to storage/innobase/include/hash0hash.ic

  • 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/include/hash0hash.ic
 
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 "ut0rnd.h"
 
10
 
 
11
/****************************************************************
 
12
Gets the nth cell in a hash table. */
 
13
UNIV_INLINE
 
14
hash_cell_t*
 
15
hash_get_nth_cell(
 
16
/*==============*/
 
17
                                /* out: pointer to cell */
 
18
        hash_table_t*   table,  /* in: hash table */
 
19
        ulint           n)      /* in: cell index */
 
20
{
 
21
        ut_ad(n < table->n_cells);
 
22
 
 
23
        return(table->array + n);
 
24
}
 
25
 
 
26
/*****************************************************************
 
27
Returns the number of cells in a hash table. */
 
28
UNIV_INLINE
 
29
ulint
 
30
hash_get_n_cells(
 
31
/*=============*/
 
32
                                /* out: number of cells */
 
33
        hash_table_t*   table)  /* in: table */
 
34
{
 
35
        return(table->n_cells);
 
36
}
 
37
 
 
38
/******************************************************************
 
39
Calculates the hash value from a folded value. */
 
40
UNIV_INLINE
 
41
ulint
 
42
hash_calc_hash(
 
43
/*===========*/
 
44
                                /* out: hashed value */
 
45
        ulint           fold,   /* in: folded value */
 
46
        hash_table_t*   table)  /* in: hash table */
 
47
{
 
48
        return(ut_hash_ulint(fold, table->n_cells));
 
49
}
 
50
 
 
51
/****************************************************************
 
52
Gets the mutex index for a fold value in a hash table. */
 
53
UNIV_INLINE
 
54
ulint
 
55
hash_get_mutex_no(
 
56
/*==============*/
 
57
                                /* out: mutex number */
 
58
        hash_table_t*   table,  /* in: hash table */
 
59
        ulint           fold)   /* in: fold */
 
60
{
 
61
        return(ut_2pow_remainder(fold, table->n_mutexes));
 
62
}
 
63
 
 
64
/****************************************************************
 
65
Gets the nth heap in a hash table. */
 
66
UNIV_INLINE
 
67
mem_heap_t*
 
68
hash_get_nth_heap(
 
69
/*==============*/
 
70
                                /* out: mem heap */
 
71
        hash_table_t*   table,  /* in: hash table */
 
72
        ulint           i)      /* in: index of the heap */
 
73
{
 
74
        ut_ad(i < table->n_mutexes);
 
75
 
 
76
        return(table->heaps[i]);
 
77
}
 
78
 
 
79
/****************************************************************
 
80
Gets the heap for a fold value in a hash table. */
 
81
UNIV_INLINE
 
82
mem_heap_t*
 
83
hash_get_heap(
 
84
/*==========*/
 
85
                                /* out: mem heap */
 
86
        hash_table_t*   table,  /* in: hash table */
 
87
        ulint           fold)   /* in: fold */
 
88
{
 
89
        ulint   i;
 
90
 
 
91
        if (table->heap) {
 
92
                return(table->heap);
 
93
        }
 
94
 
 
95
        i = hash_get_mutex_no(table, fold);
 
96
 
 
97
        return(hash_get_nth_heap(table, i));
 
98
}
 
99
 
 
100
/****************************************************************
 
101
Gets the nth mutex in a hash table. */
 
102
UNIV_INLINE
 
103
mutex_t*
 
104
hash_get_nth_mutex(
 
105
/*===============*/
 
106
                                /* out: mutex */
 
107
        hash_table_t*   table,  /* in: hash table */
 
108
        ulint           i)      /* in: index of the mutex */
 
109
{
 
110
        ut_ad(i < table->n_mutexes);
 
111
 
 
112
        return(table->mutexes + i);
 
113
}
 
114
 
 
115
/****************************************************************
 
116
Gets the mutex for a fold value in a hash table. */
 
117
UNIV_INLINE
 
118
mutex_t*
 
119
hash_get_mutex(
 
120
/*===========*/
 
121
                                /* out: mutex */
 
122
        hash_table_t*   table,  /* in: hash table */
 
123
        ulint           fold)   /* in: fold */
 
124
{
 
125
        ulint   i;
 
126
 
 
127
        i = hash_get_mutex_no(table, fold);
 
128
 
 
129
        return(hash_get_nth_mutex(table, i));
 
130
}