← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/table/cache.cc

  • Committer: Brian Aker
  • Date: 2011-02-22 06:12:02 UTC
  • mfrom: (2190.1.6 drizzle-build)
  • Revision ID: brian@tangent.org-20110222061202-k03czxykqy4x9hjs
List update, header fixes, multiple symbols, and David deletes some code.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/table/cache.cc
18
18
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
19
19
 */
20
20
 
21
 
#include "config.h"
 
21
#include <config.h>
22
22
 
23
23
#include <sys/types.h>
24
24
#include <sys/stat.h>
25
25
#include <fcntl.h>
26
26
 
27
27
 
28
 
#include "drizzled/identifier/table.h"
29
 
#include "drizzled/table.h"
30
 
#include "drizzled/session.h"
31
 
#include "drizzled/table/concurrent.h"
32
 
 
33
 
#include "drizzled/table/cache.h"
34
 
#include "drizzled/table/unused.h"
35
 
 
36
 
#include "drizzled/pthread_globals.h"
 
28
#include <drizzled/identifier.h>
 
29
#include <drizzled/table.h>
 
30
#include <drizzled/session.h>
 
31
#include <drizzled/table/concurrent.h>
 
32
 
 
33
#include <drizzled/table/cache.h>
 
34
#include <drizzled/table/unused.h>
 
35
 
 
36
#include <drizzled/pthread_globals.h>
37
37
 
38
38
namespace drizzled
39
39
{
56
56
  entry         Table to remove
57
57
 
58
58
  NOTE
59
 
  We need to have a lock on LOCK_open when calling this
 
59
  We need to have a lock on table::Cache::singleton().mutex() when calling this
60
60
*/
61
61
 
62
62
static void free_cache_entry(table::Concurrent *table)
67
67
    getUnused().unlink(table);
68
68
  }
69
69
 
70
 
  delete table;
 
70
  boost::checked_delete(table);
71
71
}
72
72
 
73
73
void remove_table(table::Concurrent *arg)
99
99
{
100
100
  do
101
101
  {
102
 
    const TableIdentifier::Key &key(table->getShare()->getCacheKey());
 
102
    const identifier::Table::Key &key(table->getShare()->getCacheKey());
103
103
 
104
104
    table::CacheRange ppp= table::getCache().equal_range(key);
105
105
 
136
136
and afterwards delete those marked unused.
137
137
*/
138
138
 
139
 
void Cache::removeSchema(const SchemaIdentifier &schema_identifier)
 
139
void Cache::removeSchema(const identifier::Schema &schema_identifier)
140
140
{
141
 
  //safe_mutex_assert_owner(LOCK_open.native_handle());
 
141
  boost::mutex::scoped_lock scopedLock(_mutex);
142
142
 
143
143
  for (table::CacheMap::const_iterator iter= table::getCache().begin();
144
144
       iter != table::getCache().end();
164
164
  close_thread_tables() is called.
165
165
 
166
166
  PREREQUISITES
167
 
  Lock on LOCK_open()
 
167
  Lock on table::Cache::singleton().mutex()()
168
168
 
169
169
  RETURN
170
170
  0  This thread now have exclusive access to this table and no other thread
172
172
  1  Table is in use by another thread
173
173
*/
174
174
 
175
 
bool Cache::removeTable(Session *session, TableIdentifier &identifier, uint32_t flags)
 
175
bool Cache::removeTable(Session *session, identifier::Table &identifier, uint32_t flags)
176
176
{
177
 
  const TableIdentifier::Key &key(identifier.getKey());
 
177
  const identifier::Table::Key &key(identifier.getKey());
178
178
  bool result= false; 
179
179
  bool signalled= false;
180
180
 
200
200
      {
201
201
        /*
202
202
          Mark that table is going to be deleted from cache. This will
203
 
          force threads that are in mysql_lock_tables() (but not yet
 
203
          force threads that are in lockTables() (but not yet
204
204
          in thr_multi_lock()) to abort it's locks, close all tables and retry
205
205
        */
206
206
        in_use->some_tables_deleted= true;
211
211
        /*
212
212
          Now we must abort all tables locks used by this thread
213
213
          as the thread may be waiting to get a lock for another table.
214
 
          Note that we need to hold LOCK_open while going through the
 
214
          Note that we need to hold table::Cache::singleton().mutex() while going through the
215
215
          list. So that the other thread cannot change it. The other
216
 
          thread must also hold LOCK_open whenever changing the
 
216
          thread must also hold table::Cache::singleton().mutex() whenever changing the
217
217
          open_tables list. Aborting the MERGE lock after a child was
218
218
          closed and before the parent is closed would be fatal.
219
219
        */
223
223
        {
224
224
          /* Do not handle locks of MERGE children. */
225
225
          if (session_table->db_stat)   // If table is open
226
 
            signalled|= mysql_lock_abort_for_thread(session, session_table);
 
226
            signalled|= session->abortLockForThread(session_table);
227
227
        }
228
228
      }
229
229
      else
235
235
    table::getUnused().cullByVersion();
236
236
 
237
237
    /* Remove table from table definition cache if it's not in use */
238
 
    TableShare::release(identifier);
 
238
    table::instance::release(identifier);
239
239
 
240
240
    if (result && (flags & RTFC_WAIT_OTHER_THREAD_FLAG))
241
241
    {
243
243
        Signal any thread waiting for tables to be freed to
244
244
        reopen their tables
245
245
      */
246
 
      broadcast_refresh();
247
 
      if (!(flags & RTFC_CHECK_KILLED_FLAG) || !session->killed)
 
246
      locking::broadcast_refresh();
 
247
      if (not (flags & RTFC_CHECK_KILLED_FLAG) || not session->getKilled())
248
248
      {
249
249
        dropping_tables++;
250
250
        if (likely(signalled))
251
251
        {
252
 
          boost_unique_lock_t scoped(LOCK_open, boost::adopt_lock_t());
 
252
          boost_unique_lock_t scoped(table::Cache::singleton().mutex(), boost::adopt_lock_t());
253
253
          COND_refresh.wait(scoped);
254
254
          scoped.release();
255
255
        }
268
268
          boost::xtime xt; 
269
269
          xtime_get(&xt, boost::TIME_UTC); 
270
270
          xt.sec += 10; 
271
 
          boost_unique_lock_t scoped(LOCK_open, boost::adopt_lock_t());
 
271
          boost_unique_lock_t scoped(table::Cache::singleton().mutex(), boost::adopt_lock_t());
272
272
          COND_refresh.timed_wait(scoped, xt);
273
273
          scoped.release();
274
274
        }