1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
|
/* Copyright (c) 2009 PrimeBase Technologies GmbH, Germany
*
* PrimeBase Media Stream for MySQL
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*
* Barry Leslie
*
* 2009-06-10
*
* H&G2JCtL
*
* PBMS transaction cache.
*
*/
#ifndef __TRANSCACHE_MS_H__
#define __TRANSCACHE_MS_H__
#include "cslib/CSDefs.h"
#include "trans_log_ms.h"
#define TRANS_CACHE_NEW_REF ((TRef)-1)
#define TRANS_CACHE_UNKNOWN_REF ((TRef)-2)
class MSTransCache : public CSSharedRefObject
{
public:
MSTransCache();
~MSTransCache();
// Prepare to add another record to a tansaction
// This will preallocate anything required so that the call
// to tc_AddRec() cannot fail.
//void tc_PrepAddRec(TRef tref, uint32_t tr_id);
// Add a transaction record to an already existing transaction
// or possible creating a new one. Depending on the record added this may
// also commit or rollback the transaction.
// Returns false if the list is full.
//void tc_AddRec(uint64_t log_position, MSTransPtr rec);
void tc_AddRec(uint64_t log_position, MSTransPtr rec, TRef tref = TRANS_CACHE_UNKNOWN_REF);
void tc_LoadRec(uint64_t log_position, MSTransPtr rec) { tc_AddRec(log_position, rec);}
// Get the transaction ref of the first transaction in the list.
// Sets terminated to true or false depending on if the transaction is terminated.
// If there is no trsansaction then false is returned.
bool tc_GetTransaction(TRef *ref, bool *terminated);
uint32_t tc_GetTransactionID(TRef ref);
// Get the state of the terminated transaction.
MS_TxnState tc_TransactionState(TRef ref);
// Remove the transaction and all record associated with it.
void tc_FreeTransaction(TRef tref);
// Get the log position of the first transaction in the list.
// Returns false if there is no transaction.
bool tc_GetTransactionStartPosition(uint64_t *log_position);
// Get the nth record for the specified transaction. A pointer to the
// storage location is passed in. If there is no nth record 'false' is returned
// otherwise the passed in record buffer is filled out and the pointer to
// it is returned.
bool tc_GetRecAt(TRef tref, size_t index, MSTransPtr rec, MS_TxnState *state);
uint32_t tc_GetCacheUsed() { return tc_Used;}
uint32_t tc_GetPercentCacheUsed() { return (tc_Used * 100)/(tc_Size-1);}
uint32_t tc_GetPercentCacheHit() { return (tc_TotalCacheCount * 100)/tc_TotalTransCount;}
// Notify the cache that recovery is in progress.
// In this case transaction records are not cached.
void tc_SetRecovering(bool recovering) {tc_Recovering = recovering;}
// Methods used to update the cache from disk.
bool tc_ShoulReloadCache(); // Test to see if the cache needs to be reloaded.
uint64_t tc_StartCacheReload(bool startup = false); // Initialize the cache for reload.
bool tc_ContinueCacheReload(); // Returns false when the cache is full.
void tc_CompleteCacheReload(); // Signal the end of the cache reload operation.
void tc_UpdateCacheVersion() {tc_CacheVersion++;}
void tc_SetSize(uint32_t cache_size); // Chang the size of the cache.
void tc_dropDatabase(uint32_t db_id); // clears records from ther cache for a dropped database.
static MSTransCache *newMSTransCache(uint32_t cache_size);
private:
void tc_Initialize(uint32_t size);
TRef tc_NewTransaction(uint32_t tid);
void tc_FindTXNRef(uint32_t tid, TRef *tref);
struct TransList *tc_List; // The transaction list, One entry per transaction.
struct TransList *tc_OverFlow; // The first transaction to overflow.
uint32_t tc_Size; // The current size of the list
uint32_t tc_EOL; // The index of the first unused transaction list record
uint32_t tc_First; // The index of the first used transaction list record
uint32_t tc_Used; // The number of used transaction list records
uint64_t tc_TotalTransCount; // The number of transaction to be cached
uint64_t tc_TotalCacheCount; // The number of transaction cached
CSThread *tc_ReLoadingThread; // The thread performing a reload.
uint32_t tc_OverFlowTID; // The transaction id of the first transaction in th reload.
bool tc_Full;
uint32_t tc_CacheVersion;
bool tc_Recovering;
#ifdef DEBUG
uint32_t tc_ReloadCnt;
#endif
};
#endif // __TRANSCACHE_MS_H__
|