← Back to branch summary

~ubuntu-branches/ubuntu/trusty/drizzle/trusty

« back to all changes in this revision

Viewing changes to plugin/myisam/keycache.h

  • Committer: Bazaar Package Importer
  • Author(s): Monty Taylor
  • Date: 2010-10-02 14:17:48 UTC
  • mfrom: (1.1.1 upstream)
  • mto: (2.1.17 sid)
  • mto: This revision was merged to the branch mainline in revision 3.
  • Revision ID: james.westby@ubuntu.com-20101002141748-m6vbfbfjhrw1153e
Tags: 2010.09.1802-1
* New upstream release.
* Removed pid-file argument hack.
* Updated GPL-2 address to be new address.
* Directly copy in drizzledump.1 since debian doesn't have sphinx 1.0 yet.
* Link to jquery from libjs-jquery. Add it as a depend.
* Add drizzled.8 symlink to the install files.

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/myisam/keycache.h
64
64
typedef struct st_key_cache
65
65
{
66
66
  bool key_cache_inited;
67
 
  bool in_resize;             /* true during resize operation             */
68
 
  bool resize_in_flush;       /* true during flush of resize operation    */
69
67
  bool can_be_used;           /* usage of cache for read/write is allowed */
70
 
  uint32_t hash_entries;             /* max number of entries in the hash table  */
71
 
  uint32_t key_cache_mem_size;      /* specified size of the cache memory       */
 
68
 
72
69
  uint32_t key_cache_block_size;     /* size of the page buffer of a cache block */
73
 
  int disk_blocks;               /* max number of blocks in the cache        */
74
 
  ulong min_warm_blocks;         /* min number of warm blocks;               */
75
 
  ulong age_threshold;           /* age threshold for hot blocks             */
76
 
  uint64_t keycache_time;       /* total number of block link operations    */
77
 
  int hash_links;                /* max number of hash links                 */
78
 
  int hash_links_used;           /* number of hash links currently used      */
79
 
  ulong blocks_used; /* maximum number of concurrently used blocks */
80
 
  ulong blocks_unused; /* number of currently unused blocks */
81
 
  ulong blocks_changed;          /* number of currently dirty blocks         */
82
 
  ulong warm_blocks;             /* number of blocks in warm sub-chain       */
83
 
  ulong cnt_for_resize_op;       /* counter to block resize operation        */
84
 
  long blocks_available;      /* number of blocks available in the LRU chain */
85
 
  HASH_LINK **hash_root;         /* arr. of entries into hash table buckets  */
86
 
  HASH_LINK *hash_link_root;     /* memory for hash table links              */
87
 
  HASH_LINK *free_hash_list;     /* list of free hash links                  */
88
 
  BLOCK_LINK *free_block_list;   /* list of free blocks */
89
 
  BLOCK_LINK *block_root;        /* memory for block links                   */
90
 
  unsigned char *block_mem;     /* memory for block buffers                 */
91
 
  BLOCK_LINK *used_last;         /* ptr to the last block of the LRU chain   */
92
 
  BLOCK_LINK *used_ins;          /* ptr to the insertion block in LRU chain  */
93
 
  pthread_mutex_t cache_lock;    /* to lock access to the cache structure    */
94
 
  KEYCACHE_WQUEUE resize_queue;  /* threads waiting during resize operation  */
95
 
  /*
96
 
    Waiting for a zero resize count. Using a queue for symmetry though
97
 
    only one thread can wait here.
98
 
  */
99
 
  KEYCACHE_WQUEUE waiting_for_resize_cnt;
100
 
  KEYCACHE_WQUEUE waiting_for_hash_link; /* waiting for a free hash link     */
101
 
  KEYCACHE_WQUEUE waiting_for_block;    /* requests waiting for a free block */
102
 
  BLOCK_LINK *changed_blocks[CHANGED_BLOCKS_HASH]; /* hash for dirty file bl.*/
103
 
  BLOCK_LINK *file_blocks[CHANGED_BLOCKS_HASH];    /* hash for other file bl.*/
104
 
 
105
 
  /*
106
 
    The following variables are and variables used to hold parameters for
107
 
    initializing the key cache.
108
 
  */
109
 
 
110
 
  uint32_t param_buff_size;    /* size the memory allocated for the cache  */
111
 
  uint32_t param_block_size;   /* size of the blocks in the key cache      */
112
 
  uint32_t param_division_limit; /* min. percentage of warm blocks           */
113
 
  uint32_t param_age_threshold;    /* determines when hot block is downgraded  */
114
70
 
115
71
  int blocks;                   /* max number of blocks in the cache        */
116
 
  /* Statistics variables. These are reset in reset_key_cache_counters(). */
117
 
  ulong global_blocks_changed;  /* number of currently dirty blocks         */
118
 
  uint64_t global_cache_w_requests;/* number of write requests (write hits) */
119
 
  uint64_t global_cache_write;     /* number of writes from cache to files  */
120
 
  uint64_t global_cache_r_requests;/* number of read requests (read hits)   */
121
 
  uint64_t global_cache_read;      /* number of reads from files to cache   */
122
72
 
123
73
  bool in_init;         /* Set to 1 in MySQL during init/resize     */
 
74
 
 
75
  st_key_cache():
 
76
    key_cache_inited(false),
 
77
    can_be_used(false),
 
78
    key_cache_block_size(0),
 
79
    blocks(0),
 
80
    in_init(0)
 
81
  { }
 
82
 
124
83
} KEY_CACHE;
125
84
 
126
85
} /* namespace drizzled */
127
86
 
128
87
/* The default key cache */
129
 
extern drizzled::KEY_CACHE dflt_key_cache_var, *dflt_key_cache;
130
 
 
131
88
extern int init_key_cache(drizzled::KEY_CACHE *keycache, uint32_t key_cache_block_size,
132
89
                          size_t use_mem, uint32_t division_limit,
133
90
                          uint32_t age_threshold);
134
 
extern int resize_key_cache(drizzled::KEY_CACHE *keycache, uint32_t key_cache_block_size,
135
 
                            size_t use_mem, uint32_t division_limit,
136
 
                            uint32_t age_threshold);
137
91
extern unsigned char *key_cache_read(drizzled::KEY_CACHE *keycache,
138
92
                            int file, drizzled::internal::my_off_t filepos, int level,
139
93
                            unsigned char *buff, uint32_t length,
149
103
                            int file, enum flush_type type);
150
104
extern void end_key_cache(drizzled::KEY_CACHE *keycache, bool cleanup);
151
105
 
152
 
extern void reset_key_cache_counters();
153
 
 
154
106
/*
155
107
  Next highest power of two
156
108