FrequentSnapshot/LL.c at master · persistLearning/FrequentSnapshot · GitHub

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
132
133
134
135
136
137
138
#include"system.h"
#include"LL.h"
extern db_server DBServer;

int db_ll_init(void *ll_info, size_t db_size)
{
	db_ll_infomation *info = ll_info;

	info->db_size = db_size;

	if (NULL == (info->db_ll_as0 = numa_alloc_onnode(DBServer.unitSize * db_size , 1))) {
		perror("db_ll_as0 malloc error");
		return -1;
	}
	memset(info->db_ll_as0, 'S', DBServer.unitSize * db_size);

	if (NULL == (info->db_ll_as1 = numa_alloc_onnode(DBServer.unitSize * db_size , 1))) {
		perror("db_ll_as1 malloc error");
		return -1;
	}
	memset(info->db_ll_as1, 'S', DBServer.unitSize * db_size);
	if (NULL == (info->db_ll_prev = numa_alloc_onnode(DBServer.unitSize * db_size , 1))) {
		perror("db_ll_prev malloc error");
		return -1;
	}
	memset(info->db_ll_prev, 'S', DBServer.unitSize * db_size);
	if (NULL == (info->db_ll_as0_ba = numa_alloc_onnode(db_size , 1))) {
		perror("db_ll_as0_ba malloc error");
		return -1;
	}
	memset(info->db_ll_as0_ba, 0, db_size);
	if (NULL == (info->db_ll_as1_ba = numa_alloc_onnode(db_size , 1))) {
		perror("db_ll_as1_ba malloc error");
		return -1;
	}
	memset(info->db_ll_as1_ba, 0, db_size);
	if (NULL == (info->db_ll_mr_ba = numa_alloc_onnode(db_size , 1))) {
		perror("db_ll_as1_ba malloc error");
		return -1;
	}
	memset(info->db_ll_mr_ba, 0, db_size);
    info->db_ll_lock = UNLOCK;
	info->current = 0;
	return 0;

}

void* ll_read(size_t index)
{
	if (index > (DBServer.llInfo).db_size)
		index = index % (DBServer.llInfo).db_size;
	if (1 == (DBServer.llInfo).current) {
		return (DBServer.llInfo).db_ll_as1 + index * DBServer.unitSize;
	} else {
		return( DBServer.llInfo).db_ll_as0 + index * DBServer.unitSize;
	}
	return NULL;
}

int ll_write(size_t index, void* value)
{
	index = index % (DBServer.llInfo).db_size;
		if (1 == (DBServer.llInfo).current) {
			memcpy((DBServer.llInfo).db_ll_as1 + index * DBServer.unitSize , value, 4);
			(DBServer.llInfo).db_ll_as1_ba[index] = 1;
		} else {
			memcpy((DBServer.llInfo).db_ll_as0 + index * DBServer.unitSize , value, 4);
			(DBServer.llInfo).db_ll_as0_ba[index] = 1;
		}
	return 0;
}

void db_ll_ckp(int ckp_order, void *ll_info)
{
	int ckp_fd;
	char ckp_name[32];
	int i;
	int db_size;
	db_ll_infomation *info;
	char *currentBackup;
	unsigned char *currentBA;
	long long timeStart;
	long long timeEnd;

	info = ll_info;
	sprintf(ckp_name, "./ckp_backup/dump_%d", ckp_order);
	if (-1 == (ckp_fd = open(ckp_name, O_WRONLY |O_TRUNC | O_SYNC | O_CREAT, 666))) {
		perror("checkpoint file open error,checkout if the ckp_backup directory is exist");
		return;
	}
	db_size = info->db_size;

    //pthread_spin_lock( &(DBServer.presync) );
	db_lock(&(DBServer.pre_lock));
	timeStart = get_ntime();
	//prepare for checkpoint
	info->current = !(info->current);
	if (0 == info->current) {
		currentBackup = info->db_ll_as1;
		currentBA = info->db_ll_as1_ba;
	} else {
		currentBackup = info->db_ll_as0;
		currentBA = info->db_ll_as0_ba;
	}
	timeEnd = get_ntime();
    //pthread_spin_unlock( &(DBServer.presync) );
	db_unlock(&(DBServer.pre_lock));
	add_prepare_log(&DBServer,timeEnd - timeStart);
	for (i = 0; i < db_size; i++) {
		if (1 == currentBA[i]) {
			//info->db_pp_as_previous[i] = info->db_pp_as_even[i];
			memcpy(info->db_ll_prev + i * DBServer.unitSize,
				currentBackup + i * DBServer.unitSize, DBServer.unitSize);
			currentBA[i] = 0;
		}
	}
	timeStart = get_utime();
	//write to disk
	#ifndef OFF_DUMP
	writeLarge(ckp_fd, info->db_ll_prev, (size_t)DBServer.unitSize * db_size, (size_t)DBServer.unitSize);
	#endif
	fsync(ckp_fd);
	close(ckp_fd);
	timeEnd = get_utime();
	add_overhead_log(&DBServer,timeEnd - timeStart);
}

void db_ll_destroy(void *ll_info)
{
	db_ll_infomation *info = ll_info;
	numa_free(info->db_ll_as1 , DBServer.unitSize * info->db_size);
	numa_free(info->db_ll_as0 , DBServer.unitSize * info->db_size);
	numa_free(info->db_ll_prev , DBServer.unitSize * info->db_size);
	numa_free(info->db_ll_as1_ba , info->db_size);
	numa_free(info->db_ll_as0_ba , info->db_size);
	numa_free(info->db_ll_mr_ba , info->db_size);

}