pdxx
/
fastdfs
mirror of https://github.com/happyfish100/fastdfs.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

use atomic counter instead of mutex lock

pull/585/head V6.09
YuQing 2022-09-14 16:33:59 +08:00
parent 6befb09fe5
commit e6fcd3ecdd
8 changed files with 151 additions and 242 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
HISTORY
View File

@ -1,6 +1,7 @@
Version 6.09 2022-09-11 Version 6.09 2022-09-14
* use libfastcommon V1.60 and libserverframe 1.1.19 * use libfastcommon V1.60 and libserverframe 1.1.19
* use atomic counter instead of mutex lock
Version 6.08 2022-06-21 Version 6.08 2022-06-21
* use libfastcommon V1.56 * use libfastcommon V1.56

47
storage/storage_dio.c
View File

@ -31,10 +31,9 @@
#include "trunk_mem.h" #include "trunk_mem.h"
#include "storage_dio.h" #include "storage_dio.h"
static pthread_mutex_t g_dio_thread_lock;
static struct storage_dio_context *g_dio_contexts = NULL; static struct storage_dio_context *g_dio_contexts = NULL;
int g_dio_thread_count = 0; volatile int g_dio_thread_count = 0;
static void *dio_thread_entrance(void* arg); static void *dio_thread_entrance(void* arg);
@ -51,11 +50,6 @@ int storage_dio_init()
pthread_t tid; pthread_t tid;
pthread_attr_t thread_attr; pthread_attr_t thread_attr;
if ((result=init_pthread_lock(&g_dio_thread_lock)) != 0)
{
return result;
}
if ((result=init_pthread_attr(&thread_attr, SF_G_THREAD_STACK_SIZE)) != 0) if ((result=init_pthread_attr(&thread_attr, SF_G_THREAD_STACK_SIZE)) != 0)
{ {
logError("file: "__FILE__", line: %d, " \ logError("file: "__FILE__", line: %d, " \
@ -120,9 +114,7 @@ int storage_dio_init()
} }
else else
{ {
pthread_mutex_lock(&g_dio_thread_lock); __sync_add_and_fetch(&g_dio_thread_count, 1);
g_dio_thread_count++;
pthread_mutex_unlock(&g_dio_thread_lock);
} }
} }
} }
@ -275,13 +267,11 @@ int dio_open_file(StorageFileContext *pFileContext)
result = 0; result = 0;
} }
pthread_mutex_lock(&g_dio_thread_lock); __sync_add_and_fetch(&g_storage_stat.total_file_open_count, 1);
g_storage_stat.total_file_open_count++;
if (result == 0) if (result == 0)
{ {
g_storage_stat.success_file_open_count++; __sync_add_and_fetch(&g_storage_stat.success_file_open_count, 1);
} }
pthread_mutex_unlock(&g_dio_thread_lock);
if (result != 0) if (result != 0)
{ {
@ -342,13 +332,11 @@ int dio_read_file(struct fast_task_info *pTask)
result, STRERROR(result)); result, STRERROR(result));
} }
pthread_mutex_lock(&g_dio_thread_lock); __sync_add_and_fetch(&g_storage_stat.total_file_read_count, 1);
g_storage_stat.total_file_read_count++;
if (result == 0) if (result == 0)
{ {
g_storage_stat.success_file_read_count++; __sync_add_and_fetch(&g_storage_stat.success_file_read_count, 1);
} }
pthread_mutex_unlock(&g_dio_thread_lock);
if (result != 0) if (result != 0)
{ {
@ -446,13 +434,11 @@ int dio_write_file(struct fast_task_info *pTask)
result, STRERROR(result)); result, STRERROR(result));
} }
pthread_mutex_lock(&g_dio_thread_lock); __sync_add_and_fetch(&g_storage_stat.total_file_write_count, 1);
g_storage_stat.total_file_write_count++;
if (result == 0) if (result == 0)
{ {
g_storage_stat.success_file_write_count++; __sync_add_and_fetch(&g_storage_stat.success_file_write_count, 1);
} }
pthread_mutex_unlock(&g_dio_thread_lock);
if (result != 0) if (result != 0)
{ {
@ -738,7 +724,6 @@ void dio_trunk_write_finish_clean_up(struct fast_task_info *pTask)
static void *dio_thread_entrance(void* arg) static void *dio_thread_entrance(void* arg)
{ {
int result;
struct storage_dio_context *pContext; struct storage_dio_context *pContext;
struct fast_task_info *pTask; struct fast_task_info *pTask;
@ -752,21 +737,7 @@ static void *dio_thread_entrance(void* arg)
} }
} }
if ((result=pthread_mutex_lock(&g_dio_thread_lock)) != 0) __sync_sub_and_fetch(&g_dio_thread_count, 1);
{
logError("file: "__FILE__", line: %d, " \
"call pthread_mutex_lock fail, " \
"errno: %d, error info: %s", \
__LINE__, result, STRERROR(result));
}
g_dio_thread_count--;
if ((result=pthread_mutex_unlock(&g_dio_thread_lock)) != 0)
{
logError("file: "__FILE__", line: %d, " \
"call pthread_mutex_lock fail, " \
"errno: %d, error info: %s", \
__LINE__, result, STRERROR(result));
}
logDebug("file: "__FILE__", line: %d, " \ logDebug("file: "__FILE__", line: %d, " \
"dio thread exited, thread count: %d", \ "dio thread exited, thread count: %d", \

2
storage/storage_dio.h
View File

@ -39,7 +39,7 @@ struct storage_dio_thread_data
extern "C" { extern "C" {
#endif #endif
extern int g_dio_thread_count; extern volatile int g_dio_thread_count;
int storage_dio_init(); int storage_dio_init();
void storage_dio_terminate(); void storage_dio_terminate();

6
storage/storage_global.c
View File

@ -32,9 +32,9 @@ int g_file_distribute_path_mode = FDFS_FILE_DIST_PATH_ROUND_ROBIN;
int g_file_distribute_rotate_count = FDFS_FILE_DIST_DEFAULT_ROTATE_COUNT; int g_file_distribute_rotate_count = FDFS_FILE_DIST_DEFAULT_ROTATE_COUNT;
int g_fsync_after_written_bytes = -1; int g_fsync_after_written_bytes = -1;
int g_dist_path_index_high = 0; //current write to high path volatile int g_dist_path_index_high = 0; //current write to high path
int g_dist_path_index_low = 0; //current write to low path volatile int g_dist_path_index_low = 0; //current write to low path
int g_dist_write_file_count = 0; //current write file count volatile int g_dist_write_file_count = 0; //current write file count
int g_storage_count = 0; int g_storage_count = 0;
FDFSStorageServer g_storage_servers[FDFS_MAX_SERVERS_EACH_GROUP]; FDFSStorageServer g_storage_servers[FDFS_MAX_SERVERS_EACH_GROUP];

6
storage/storage_global.h
View File

@ -64,9 +64,9 @@ extern int g_file_distribute_path_mode;
extern int g_file_distribute_rotate_count; extern int g_file_distribute_rotate_count;
extern int g_fsync_after_written_bytes; extern int g_fsync_after_written_bytes;
extern int g_dist_path_index_high; //current write to high path extern volatile int g_dist_path_index_high; //current write to high path
extern int g_dist_path_index_low; //current write to low path extern volatile int g_dist_path_index_low; //current write to low path
extern int g_dist_write_file_count; //current write file count extern volatile int g_dist_write_file_count; //current write file count
extern int g_storage_count; //stoage server count in my group extern int g_storage_count; //stoage server count in my group
extern FDFSStorageServer g_storage_servers[FDFS_MAX_SERVERS_EACH_GROUP]; extern FDFSStorageServer g_storage_servers[FDFS_MAX_SERVERS_EACH_GROUP];

191
storage/storage_service.c
View File

@ -29,6 +29,7 @@
#include "fastcommon/pthread_func.h" #include "fastcommon/pthread_func.h"
#include "fastcommon/sched_thread.h" #include "fastcommon/sched_thread.h"
#include "fastcommon/fast_mblock.h" #include "fastcommon/fast_mblock.h"
#include "fastcommon/fc_atomic.h"
#include "sf/sf_service.h" #include "sf/sf_service.h"
#include "sf/sf_nio.h" #include "sf/sf_nio.h"
#include "tracker_types.h" #include "tracker_types.h"
@ -72,9 +73,6 @@ typedef struct
static int last_stat_change_count = 1; //for sync to stat file static int last_stat_change_count = 1; //for sync to stat file
static volatile int64_t temp_file_sequence = 0; static volatile int64_t temp_file_sequence = 0;
static pthread_mutex_t path_index_thread_lock;
static pthread_mutex_t stat_count_thread_lock;
static struct fast_mblock_man finfo_for_crc32_allocator; static struct fast_mblock_man finfo_for_crc32_allocator;
extern int storage_client_create_link(ConnectionInfo *pTrackerServer, \ extern int storage_client_create_link(ConnectionInfo *pTrackerServer, \
@ -190,7 +188,6 @@ static FDFSStorageServer *get_storage_server(const char *storage_server_id)
} }
#define CHECK_AND_WRITE_TO_STAT_FILE1 \ #define CHECK_AND_WRITE_TO_STAT_FILE1 \
pthread_mutex_lock(&stat_count_thread_lock); \
\ \
if (pClientInfo->pSrcStorage == NULL) \ if (pClientInfo->pSrcStorage == NULL) \
{ \ { \
@ -206,11 +203,9 @@ static FDFSStorageServer *get_storage_server(const char *storage_server_id)
\ \
g_storage_stat.last_sync_update = g_current_time; \ g_storage_stat.last_sync_update = g_current_time; \
++g_stat_change_count; \ ++g_stat_change_count; \
pthread_mutex_unlock(&stat_count_thread_lock);
#define CHECK_AND_WRITE_TO_STAT_FILE1_WITH_BYTES( \ #define CHECK_AND_WRITE_TO_STAT_FILE1_WITH_BYTES( \
total_bytes, success_bytes, bytes) \ total_bytes, success_bytes, bytes) \
pthread_mutex_lock(&stat_count_thread_lock); \
\ \
if (pClientInfo->pSrcStorage == NULL) \ if (pClientInfo->pSrcStorage == NULL) \
{ \ { \
@ -225,46 +220,37 @@ static FDFSStorageServer *get_storage_server(const char *storage_server_id)
} \ } \
\ \
g_storage_stat.last_sync_update = g_current_time; \ g_storage_stat.last_sync_update = g_current_time; \
total_bytes += bytes; \ __sync_add_and_fetch(&total_bytes, bytes); \
success_bytes += bytes; \ __sync_add_and_fetch(&success_bytes, bytes); \
++g_stat_change_count; \ ++g_stat_change_count; \
pthread_mutex_unlock(&stat_count_thread_lock);
#define CHECK_AND_WRITE_TO_STAT_FILE2(total_count, success_count) \ #define CHECK_AND_WRITE_TO_STAT_FILE2(total_count, success_count) \
pthread_mutex_lock(&stat_count_thread_lock); \ __sync_add_and_fetch(&total_count, 1); \
total_count++; \ __sync_add_and_fetch(&success_count, 1); \
success_count++; \
++g_stat_change_count; \ ++g_stat_change_count; \
pthread_mutex_unlock(&stat_count_thread_lock);
#define CHECK_AND_WRITE_TO_STAT_FILE2_WITH_BYTES(total_count, success_count, \ #define CHECK_AND_WRITE_TO_STAT_FILE2_WITH_BYTES(total_count, success_count, \
total_bytes, success_bytes, bytes) \ total_bytes, success_bytes, bytes) \
pthread_mutex_lock(&stat_count_thread_lock); \ __sync_add_and_fetch(&total_count, 1); \
total_count++; \ __sync_add_and_fetch(&success_count, 1); \
success_count++; \ __sync_add_and_fetch(&total_bytes, bytes); \
total_bytes += bytes; \ __sync_add_and_fetch(&success_bytes, bytes);\
success_bytes += bytes; \
++g_stat_change_count; \ ++g_stat_change_count; \
pthread_mutex_unlock(&stat_count_thread_lock);
#define CHECK_AND_WRITE_TO_STAT_FILE3(total_count, success_count, timestamp) \ #define CHECK_AND_WRITE_TO_STAT_FILE3(total_count, success_count, timestamp) \
pthread_mutex_lock(&stat_count_thread_lock); \ __sync_add_and_fetch(&total_count, 1); \
total_count++; \ __sync_add_and_fetch(&success_count, 1); \
success_count++; \
timestamp = g_current_time; \ timestamp = g_current_time; \
++g_stat_change_count; \ ++g_stat_change_count; \
pthread_mutex_unlock(&stat_count_thread_lock);
#define CHECK_AND_WRITE_TO_STAT_FILE3_WITH_BYTES(total_count, success_count, \ #define CHECK_AND_WRITE_TO_STAT_FILE3_WITH_BYTES(total_count, success_count, \
timestamp, total_bytes, success_bytes, bytes) \ timestamp, total_bytes, success_bytes, bytes) \
pthread_mutex_lock(&stat_count_thread_lock); \ __sync_add_and_fetch(&total_count, 1); \
total_count++; \ __sync_add_and_fetch(&success_count, 1); \
success_count++; \ __sync_add_and_fetch(&total_bytes, bytes); \
__sync_add_and_fetch(&success_bytes, bytes); \
timestamp = g_current_time; \ timestamp = g_current_time; \
total_bytes += bytes; \
success_bytes += bytes; \
++g_stat_change_count; \ ++g_stat_change_count; \
pthread_mutex_unlock(&stat_count_thread_lock);
static void storage_log_access_log(struct fast_task_info *pTask, \ static void storage_log_access_log(struct fast_task_info *pTask, \
const char *action, const int status) const char *action, const int status)
@ -577,10 +563,8 @@ static void storage_sync_copy_file_done_callback(struct fast_task_info *pTask, \
} }
if (result != 0) if (result != 0)
{ {
pthread_mutex_lock(&stat_count_thread_lock); __sync_add_and_fetch(&g_storage_stat.total_sync_in_bytes,
g_storage_stat.total_sync_in_bytes += \ pClientInfo->total_offset);
pClientInfo->total_offset;
pthread_mutex_unlock(&stat_count_thread_lock);
} }
pClientInfo->total_length = sizeof(TrackerHeader); pClientInfo->total_length = sizeof(TrackerHeader);
@ -655,10 +639,8 @@ static void storage_sync_modify_file_done_callback( \
if (result != 0) if (result != 0)
{ {
pthread_mutex_lock(&stat_count_thread_lock); __sync_add_and_fetch(&g_storage_stat.total_sync_in_bytes,
g_storage_stat.total_sync_in_bytes += \ pClientInfo->total_offset);
pClientInfo->total_offset;
pthread_mutex_unlock(&stat_count_thread_lock);
} }
pClientInfo->total_length = sizeof(TrackerHeader); pClientInfo->total_length = sizeof(TrackerHeader);
@ -673,7 +655,7 @@ static void storage_sync_modify_file_done_callback( \
sf_nio_notify(pTask, SF_NIO_STAGE_SEND); sf_nio_notify(pTask, SF_NIO_STAGE_SEND);
} }
static void storage_get_metadata_done_callback(struct fast_task_info *pTask, \ static void storage_get_metadata_done_callback(struct fast_task_info *pTask,
const int err_no) const int err_no)
{ {
TrackerHeader *pHeader; TrackerHeader *pHeader;
@ -683,10 +665,7 @@ static void storage_get_metadata_done_callback(struct fast_task_info *pTask, \
if (err_no != 0) if (err_no != 0)
{ {
pthread_mutex_lock(&stat_count_thread_lock); __sync_add_and_fetch(&g_storage_stat.total_get_meta_count, 1);
g_storage_stat.total_get_meta_count++;
pthread_mutex_unlock(&stat_count_thread_lock);
if (pTask->length == sizeof(TrackerHeader)) //never response if (pTask->length == sizeof(TrackerHeader)) //never response
{ {
pHeader = (TrackerHeader *)pTask->data; pHeader = (TrackerHeader *)pTask->data;
@ -720,11 +699,9 @@ static void storage_download_file_done_callback( \
pFileContext = &(((StorageClientInfo *)pTask->arg)->file_context); pFileContext = &(((StorageClientInfo *)pTask->arg)->file_context);
if (err_no != 0) if (err_no != 0)
{ {
pthread_mutex_lock(&stat_count_thread_lock); __sync_add_and_fetch(&g_storage_stat.total_download_count, 1);
g_storage_stat.total_download_count++; __sync_add_and_fetch(&g_storage_stat.total_download_bytes,
g_storage_stat.total_download_bytes += \ pFileContext->offset - pFileContext->start);
pFileContext->offset - pFileContext->start;
pthread_mutex_unlock(&stat_count_thread_lock);
if (pTask->length == sizeof(TrackerHeader)) //never response if (pTask->length == sizeof(TrackerHeader)) //never response
{ {
@ -1069,17 +1046,15 @@ static void storage_delete_fdfs_file_done_callback( \
if (result != 0) if (result != 0)
{ {
pthread_mutex_lock(&stat_count_thread_lock); if (pFileContext->delete_flag == STORAGE_DELETE_FLAG_NONE ||
if (pFileContext->delete_flag == STORAGE_DELETE_FLAG_NONE ||\
(pFileContext->delete_flag & STORAGE_DELETE_FLAG_FILE)) (pFileContext->delete_flag & STORAGE_DELETE_FLAG_FILE))
{ {
g_storage_stat.total_delete_count++; __sync_add_and_fetch(&g_storage_stat.total_delete_count, 1);
} }
if (pFileContext->delete_flag & STORAGE_DELETE_FLAG_LINK) if (pFileContext->delete_flag & STORAGE_DELETE_FLAG_LINK)
{ {
g_storage_stat.total_delete_link_count++; __sync_add_and_fetch(&g_storage_stat.total_delete_link_count, 1);
} }
pthread_mutex_unlock(&stat_count_thread_lock);
} }
else else
{ {
@ -1182,14 +1157,12 @@ static void storage_upload_file_done_callback(struct fast_task_info *pTask, \
} }
else else
{ {
pthread_mutex_lock(&stat_count_thread_lock);
if (pFileContext->create_flag & STORAGE_CREATE_FLAG_FILE) if (pFileContext->create_flag & STORAGE_CREATE_FLAG_FILE)
{ {
g_storage_stat.total_upload_count++; __sync_add_and_fetch(&g_storage_stat.total_upload_count, 1);
g_storage_stat.total_upload_bytes += \ __sync_add_and_fetch(&g_storage_stat.total_upload_bytes,
pClientInfo->total_offset; pClientInfo->total_offset);
} }
pthread_mutex_unlock(&stat_count_thread_lock);
pClientInfo->total_length = sizeof(TrackerHeader); pClientInfo->total_length = sizeof(TrackerHeader);
} }
@ -1275,9 +1248,7 @@ static void storage_trunk_create_link_file_done_callback( \
} }
else else
{ {
pthread_mutex_lock(&stat_count_thread_lock); __sync_add_and_fetch(&g_storage_stat.total_create_link_count, 1);
g_storage_stat.total_create_link_count++;
pthread_mutex_unlock(&stat_count_thread_lock);
pClientInfo->total_length = sizeof(TrackerHeader); pClientInfo->total_length = sizeof(TrackerHeader);
} }
@ -1349,10 +1320,9 @@ static void storage_append_file_done_callback(struct fast_task_info *pTask, \
} }
else else
{ {
pthread_mutex_lock(&stat_count_thread_lock); __sync_add_and_fetch(&g_storage_stat.total_append_count, 1);
g_storage_stat.total_append_count++; __sync_add_and_fetch(&g_storage_stat.total_append_bytes,
g_storage_stat.total_append_bytes += pClientInfo->total_offset; pClientInfo->total_offset);
pthread_mutex_unlock(&stat_count_thread_lock);
} }
pClientInfo->total_length = sizeof(TrackerHeader); pClientInfo->total_length = sizeof(TrackerHeader);
@ -1419,10 +1389,9 @@ static void storage_modify_file_done_callback(struct fast_task_info *pTask, \
} }
else else
{ {
pthread_mutex_lock(&stat_count_thread_lock); __sync_add_and_fetch(&g_storage_stat.total_modify_count, 1);
g_storage_stat.total_modify_count++; __sync_add_and_fetch(&g_storage_stat.total_modify_bytes,
g_storage_stat.total_modify_bytes += pClientInfo->total_offset; pClientInfo->total_offset);
pthread_mutex_unlock(&stat_count_thread_lock);
} }
pClientInfo->total_length = sizeof(TrackerHeader); pClientInfo->total_length = sizeof(TrackerHeader);
@ -1485,9 +1454,7 @@ static void storage_do_truncate_file_done_callback(struct fast_task_info *pTask,
} }
else else
{ {
pthread_mutex_lock(&stat_count_thread_lock); __sync_add_and_fetch(&g_storage_stat.total_truncate_count, 1);
g_storage_stat.total_truncate_count++;
pthread_mutex_unlock(&stat_count_thread_lock);
} }
pClientInfo->total_length = sizeof(TrackerHeader); pClientInfo->total_length = sizeof(TrackerHeader);
@ -1534,9 +1501,7 @@ static void storage_set_metadata_done_callback( \
if (result != 0) if (result != 0)
{ {
pthread_mutex_lock(&stat_count_thread_lock); __sync_add_and_fetch(&g_storage_stat.total_set_meta_count, 1);
g_storage_stat.total_set_meta_count++;
pthread_mutex_unlock(&stat_count_thread_lock);
} }
else else
{ {
@ -1682,16 +1647,6 @@ int storage_service_init()
{ {
int result; int result;
if ((result=init_pthread_lock(&path_index_thread_lock)) != 0)
{
return result;
}
if ((result=init_pthread_lock(&stat_count_thread_lock)) != 0)
{
return result;
}
last_stat_change_count = g_stat_change_count; last_stat_change_count = g_stat_change_count;
if ((result=fast_mblock_init(&finfo_for_crc32_allocator, if ((result=fast_mblock_init(&finfo_for_crc32_allocator,
sizeof(StorageFileInfoForCRC32), 1024)) != 0) sizeof(StorageFileInfoForCRC32), 1024)) != 0)
@ -1711,8 +1666,6 @@ int storage_service_init()
void storage_service_destroy() void storage_service_destroy()
{ {
pthread_mutex_destroy(&path_index_thread_lock);
pthread_mutex_destroy(&stat_count_thread_lock);
} }
int storage_get_storage_path_index(int *store_path_index) int storage_get_storage_path_index(int *store_path_index)
@ -1772,51 +1725,41 @@ void storage_get_store_path(const char *filename, const int filename_len, \
int *sub_path_high, int *sub_path_low) int *sub_path_high, int *sub_path_low)
{ {
int n; int n;
int result; int write_file_count;
int path_index_high;
if (g_file_distribute_path_mode == FDFS_FILE_DIST_PATH_ROUND_ROBIN) if (g_file_distribute_path_mode == FDFS_FILE_DIST_PATH_ROUND_ROBIN)
{ {
*sub_path_high = g_dist_path_index_high; *sub_path_high = FC_ATOMIC_GET(g_dist_path_index_high);
*sub_path_low = g_dist_path_index_low; *sub_path_low = FC_ATOMIC_GET(g_dist_path_index_low);
while (1) {
if (++g_dist_write_file_count >= g_file_distribute_rotate_count) write_file_count = __sync_add_and_fetch(
&g_dist_write_file_count, 1);
if (write_file_count < g_file_distribute_rotate_count)
{ {
g_dist_write_file_count = 0; break;
if ((result=pthread_mutex_lock( \
&path_index_thread_lock)) != 0)
{
logError("file: "__FILE__", line: %d, " \
"call pthread_mutex_lock fail, " \
"errno: %d, error info: %s", \
__LINE__, result, STRERROR(result));
} }
if (write_file_count == g_file_distribute_rotate_count)
++g_dist_path_index_low; {
if (g_dist_path_index_low >= g_subdir_count_per_path) if (__sync_add_and_fetch(&g_dist_path_index_low, 1) >=
g_subdir_count_per_path)
{ //rotate { //rotate
g_dist_path_index_high++; path_index_high = __sync_add_and_fetch(
if (g_dist_path_index_high >= \ &g_dist_path_index_high, 1);
g_subdir_count_per_path) //rotate if (path_index_high >= g_subdir_count_per_path) //rotate
{ {
g_dist_path_index_high = 0; FC_ATOMIC_SET(g_dist_path_index_high, 0);
} }
g_dist_path_index_low = 0; FC_ATOMIC_SET(g_dist_path_index_low, 0);
} }
FC_ATOMIC_SET(g_dist_write_file_count, 0);
++g_stat_change_count; ++g_stat_change_count;
break;
if ((result=pthread_mutex_unlock( \
&path_index_thread_lock)) != 0)
{
logError("file: "__FILE__", line: %d, " \
"call pthread_mutex_unlock fail, " \
"errno: %d, error info: %s", \
__LINE__, result, STRERROR(result));
} }
} }
} //random }
else else //random
{ {
n = PJWHash(filename, filename_len) % (1 << 16); n = PJWHash(filename, filename_len) % (1 << 16);
*sub_path_high = ((n >> 8) & 0xFF) % g_subdir_count_per_path; *sub_path_high = ((n >> 8) & 0xFF) % g_subdir_count_per_path;
@ -7002,9 +6945,7 @@ static int storage_server_download_file(struct fast_task_info *pTask)
&trunkInfo, &trunkHeader, &pFileContext->fd); &trunkInfo, &trunkHeader, &pFileContext->fd);
if (IS_TRUNK_FILE_BY_ID(trunkInfo)) if (IS_TRUNK_FILE_BY_ID(trunkInfo))
{ {
pthread_mutex_lock(&stat_count_thread_lock); __sync_add_and_fetch(&g_storage_stat.total_file_open_count, 1);
g_storage_stat.total_file_open_count++;
pthread_mutex_unlock(&stat_count_thread_lock);
} }
if (result == 0) if (result == 0)
{ {
@ -7028,9 +6969,7 @@ static int storage_server_download_file(struct fast_task_info *pTask)
if (IS_TRUNK_FILE_BY_ID(trunkInfo)) if (IS_TRUNK_FILE_BY_ID(trunkInfo))
{ {
pthread_mutex_lock(&stat_count_thread_lock); __sync_add_and_fetch(&g_storage_stat.success_file_open_count, 1);
g_storage_stat.success_file_open_count++;
pthread_mutex_unlock(&stat_count_thread_lock);
} }
if (download_bytes == 0) if (download_bytes == 0)
@ -7726,9 +7665,7 @@ static int storage_create_link_core(struct fast_task_info *pTask, \
} }
else else
{ {
pthread_mutex_lock(&stat_count_thread_lock); __sync_add_and_fetch(&g_storage_stat.total_create_link_count, 1);
g_storage_stat.total_create_link_count++;
pthread_mutex_unlock(&stat_count_thread_lock);
} }
return result; return result;

16
storage/storage_sync.c
View File

@ -265,13 +265,13 @@ static int storage_sync_copy_file(ConnectionInfo *pStorageServer, \
} }
} while (0); } while (0);
pthread_mutex_lock(&sync_thread_lock); __sync_add_and_fetch(&g_storage_stat.total_sync_out_bytes,
g_storage_stat.total_sync_out_bytes += total_send_bytes; total_send_bytes);
if (result == 0) if (result == 0)
{ {
g_storage_stat.success_sync_out_bytes += total_send_bytes; __sync_add_and_fetch(&g_storage_stat.success_sync_out_bytes,
total_send_bytes);
} }
pthread_mutex_unlock(&sync_thread_lock);
if (result == EEXIST) if (result == EEXIST)
{ {
@ -461,13 +461,13 @@ static int storage_sync_modify_file(ConnectionInfo *pStorageServer, \
} }
} while (0); } while (0);
pthread_mutex_lock(&sync_thread_lock); __sync_add_and_fetch(&g_storage_stat.total_sync_out_bytes,
g_storage_stat.total_sync_out_bytes += total_send_bytes; total_send_bytes);
if (result == 0) if (result == 0)
{ {
g_storage_stat.success_sync_out_bytes += total_send_bytes; __sync_add_and_fetch(&g_storage_stat.success_sync_out_bytes,
total_send_bytes);
} }
pthread_mutex_unlock(&sync_thread_lock);
return result == EEXIST ? 0 : result; return result == EEXIST ? 0 : result;
} }

76
tracker/tracker_types.h
View File

@ -159,44 +159,44 @@ typedef struct
/* following count stat by source server, /* following count stat by source server,
not including synced count not including synced count
*/ */
int64_t total_upload_count; volatile int64_t total_upload_count;
int64_t success_upload_count; volatile int64_t success_upload_count;
int64_t total_append_count; volatile int64_t total_append_count;
int64_t success_append_count; volatile int64_t success_append_count;
int64_t total_modify_count; volatile int64_t total_modify_count;
int64_t success_modify_count; volatile int64_t success_modify_count;
int64_t total_truncate_count; volatile int64_t total_truncate_count;
int64_t success_truncate_count; volatile int64_t success_truncate_count;
int64_t total_set_meta_count; volatile int64_t total_set_meta_count;
int64_t success_set_meta_count; volatile int64_t success_set_meta_count;
int64_t total_delete_count; volatile int64_t total_delete_count;
int64_t success_delete_count; volatile int64_t success_delete_count;
int64_t total_download_count; volatile int64_t total_download_count;
int64_t success_download_count; volatile int64_t success_download_count;
int64_t total_get_meta_count; volatile int64_t total_get_meta_count;
int64_t success_get_meta_count; volatile int64_t success_get_meta_count;
int64_t total_create_link_count; volatile int64_t total_create_link_count;
int64_t success_create_link_count; volatile int64_t success_create_link_count;
int64_t total_delete_link_count; volatile int64_t total_delete_link_count;
int64_t success_delete_link_count; volatile int64_t success_delete_link_count;
int64_t total_upload_bytes; volatile int64_t total_upload_bytes;
int64_t success_upload_bytes; volatile int64_t success_upload_bytes;
int64_t total_append_bytes; volatile int64_t total_append_bytes;
int64_t success_append_bytes; volatile int64_t success_append_bytes;
int64_t total_modify_bytes; volatile int64_t total_modify_bytes;
int64_t success_modify_bytes; volatile int64_t success_modify_bytes;
int64_t total_download_bytes; volatile int64_t total_download_bytes;
int64_t success_download_bytes; volatile int64_t success_download_bytes;
int64_t total_sync_in_bytes; volatile int64_t total_sync_in_bytes;
int64_t success_sync_in_bytes; volatile int64_t success_sync_in_bytes;
int64_t total_sync_out_bytes; volatile int64_t total_sync_out_bytes;
int64_t success_sync_out_bytes; volatile int64_t success_sync_out_bytes;
int64_t total_file_open_count; volatile int64_t total_file_open_count;
int64_t success_file_open_count; volatile int64_t success_file_open_count;
int64_t total_file_read_count; volatile int64_t total_file_read_count;
int64_t success_file_read_count; volatile int64_t success_file_read_count;
int64_t total_file_write_count; volatile int64_t total_file_write_count;
int64_t success_file_write_count; volatile int64_t success_file_write_count;
/* last update timestamp as source server, /* last update timestamp as source server,
current server' timestamp current server' timestamp