ae/CPP_Core
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

重新设置代码格式

Browse Source
This commit is contained in:
种太阳的热带美短
2026-06-25 15:44:25 +08:00
parent 4669ba9c6b
commit d1f0f6e836
77 changed files with 9557 additions and 9416 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Core/Shared_Memory/Shared_Memory_linux.cpp
+143 -139
View File
@@ -4,6 +4,8 @@
#include <sys/stat.h>
#include <unistd.h>
#include "Core/spdlog/export.h"
#include "Shared_Memory.h"
#include <atomic>
#include <cstring>
#include <fcntl.h>
@@ -13,156 +15,158 @@
#include <sys/mman.h>
#include <sys/stat.h>
#include <unistd.h>
#include "Core/spdlog/export.h"
#include "Shared_Memory.h"
namespace Psc {
bool check_if_shared_memory_exists(const std::string &name) {
int fd = shm_open(name.c_str(), O_RDWR, 0777);
if (fd < 0) {
return false;
}
close(fd);
return true;
bool check_if_shared_memory_exists(const std::string &name) {
int fd = shm_open(name.c_str(), O_RDWR, 0777);
if (fd < 0) {
return false;
}
close(fd);
return true;
}
Shared_Memory::~Shared_Memory() { close(); }
bool Shared_Memory::create(const std::string &name, size_t size) {
m_name = name;
m_size = size;
m_fd = shm_open(name.c_str(), O_CREAT | O_RDWR, 0777);
if (m_fd < 0)
return false;
if (ftruncate(m_fd, size) != 0)
return false;
m_ptr = mmap(nullptr, size, PROT_READ | PROT_WRITE, MAP_SHARED, m_fd, 0);
if (fchmod(m_fd, 0777) != 0) {
std::cerr << "修改共享内存权限失败: " << get_error_message() << std::endl;
Psc::fail_fast();
}
return m_ptr != MAP_FAILED;
}
bool Shared_Memory::open(const std::string &name, size_t size) {
m_name = name;
m_size = size;
m_fd = shm_open(name.c_str(), O_RDWR, 0777);
if (m_fd < 0)
return false;
m_ptr = mmap(nullptr, size, PROT_READ | PROT_WRITE, MAP_SHARED, m_fd, 0);
return m_ptr != MAP_FAILED;
}
void Shared_Memory::close() {
// if (m_ptr) {
// munmap(m_ptr, m_size);
// m_ptr = nullptr;
// }
if (m_fd >= 0) {
::close(m_fd);
m_fd = -1;
}
}
void Shared_Memory::unlink() {
if (!m_name.empty())
shm_unlink(m_name.c_str());
}
struct MutexBlock {
pthread_mutex_t mutex;
std::atomic<int> initialized; // 0 = 未初始化, 1 = 初始化完成
};
Cross_Process_Mutex::Cross_Process_Mutex() {}
void Cross_Process_Mutex::init(const std::string &mutexName) {
this->m_mutexName = mutexName;
bool creator = false;
// 第一次创建尝试 O_EXCL，能判断是否首次创建
m_fd = shm_open(m_mutexName.c_str(), O_RDWR | O_CREAT | O_EXCL, 0777);
if (m_fd >= 0) {
creator = true;
if (ftruncate(m_fd, sizeof(MutexBlock)) < 0) {
std::cout << "跨进程锁" << mutexName << "创建失败 ["
<< get_error_message() << "] " << LOG_POS << std::endl;
Psc::fail_fast();
}
Shared_Memory::~Shared_Memory() {
close();
if (fchmod(m_fd, 0777) != 0) {
std::cerr << "修改共享内存权限失败: " << get_error_message() << LOG_POS
<< std::endl;
Psc::fail_fast();
}
bool Shared_Memory::create(const std::string &name, size_t size) {
m_name = name;
m_size = size;
m_fd = shm_open(name.c_str(), O_CREAT | O_RDWR, 0777);
if (m_fd < 0) return false;
if (ftruncate(m_fd, size) != 0) return false;
m_ptr = mmap(nullptr, size, PROT_READ | PROT_WRITE, MAP_SHARED, m_fd, 0);
if (fchmod(m_fd, 0777) != 0) {
std::cerr << "修改共享内存权限失败: " << get_error_message() << std::endl;
Psc::fail_fast();
}
return m_ptr != MAP_FAILED;
} else if (errno == EEXIST) {
// 已经存在，只打开，不改大小
m_fd = shm_open(m_mutexName.c_str(), O_RDWR, 0777);
if (m_fd < 0) {
std::cout << "跨进程锁" << mutexName << "打开失败 ["
<< get_error_message() << "] " << LOG_POS << std::endl;
Psc::fail_fast();
}
bool Shared_Memory::open(const std::string &name, size_t size) {
m_name = name;
m_size = size;
m_fd = shm_open(name.c_str(), O_RDWR, 0777);
if (m_fd < 0) return false;
m_ptr = mmap(nullptr, size, PROT_READ | PROT_WRITE, MAP_SHARED, m_fd, 0);
return m_ptr != MAP_FAILED;
} else {
std::cout << "跨进程锁" << mutexName << "检测失败 [" << get_error_message()
<< "] " << LOG_POS << std::endl;
Psc::fail_fast();
}
// 映射
m_addr = mmap(nullptr, sizeof(MutexBlock), PROT_READ | PROT_WRITE, MAP_SHARED,
m_fd, 0);
if (m_addr == MAP_FAILED) {
std::cout << "跨进程锁" << mutexName << "mmap失败 [" << get_error_message()
<< "] " << LOG_POS << std::endl;
Psc::fail_fast();
}
auto block = static_cast<MutexBlock *>(m_addr);
if (creator) {
// 创建者初始化
memset(&block->mutex, 0, sizeof(pthread_mutex_t));
block->initialized.store(0, std::memory_order_relaxed);
pthread_mutexattr_t attr;
pthread_mutexattr_init(&attr);
pthread_mutexattr_setpshared(&attr, PTHREAD_PROCESS_SHARED);
pthread_mutexattr_setrobust(&attr, PTHREAD_MUTEX_ROBUST);
if (pthread_mutex_init(&block->mutex, &attr) != 0) {
pthread_mutexattr_destroy(&attr);
std::cout << "跨进程锁" << mutexName << "init失败 ["
<< get_error_message() << "] " << LOG_POS << std::endl;
Psc::fail_fast();
}
void Shared_Memory::close() {
// if (m_ptr) {
// munmap(m_ptr, m_size);
// m_ptr = nullptr;
// }
if (m_fd >= 0) {
::close(m_fd);
m_fd = -1;
}
}
void Shared_Memory::unlink() {
if (!m_name.empty()) shm_unlink(m_name.c_str());
pthread_mutexattr_destroy(&attr);
block->initialized.store(1, std::memory_order_release);
} else {
// 后来者等待初始化完成
auto ib = &block->initialized;
while (ib->load(std::memory_order_acquire) != 1) {
sched_yield();
}
}
}
Cross_Process_Mutex::~Cross_Process_Mutex() {
// if (m_addr) munmap(m_addr, sizeof(MutexBlock));
//
close(m_fd);
}
struct MutexBlock {
pthread_mutex_t mutex;
std::atomic<int> initialized; // 0 = 未初始化, 1 = 初始化完成
};
Cross_Process_Mutex::Cross_Process_Mutex() {
}
void Cross_Process_Mutex::init(const std::string &mutexName) {
this->m_mutexName = mutexName;
bool creator = false;
// 第一次创建尝试 O_EXCL，能判断是否首次创建
m_fd = shm_open(m_mutexName.c_str(), O_RDWR | O_CREAT | O_EXCL, 0777);
if (m_fd >= 0) {
creator = true;
if (ftruncate(m_fd, sizeof(MutexBlock)) < 0) {
std::cout << "跨进程锁" << mutexName << "创建失败 [" << get_error_message() << "] " << LOG_POS <<std::endl;
Psc::fail_fast();
}
if (fchmod(m_fd, 0777) != 0) {
std::cerr << "修改共享内存权限失败: " << get_error_message() << LOG_POS << std::endl;
Psc::fail_fast();
}
} else if (errno == EEXIST) {
// 已经存在，只打开，不改大小
m_fd = shm_open(m_mutexName.c_str(), O_RDWR, 0777);
if (m_fd < 0) {
std::cout << "跨进程锁" << mutexName << "打开失败 [" << get_error_message() << "] " << LOG_POS <<std::endl;
Psc::fail_fast();
}
} else {
std::cout << "跨进程锁" << mutexName << "检测失败 [" << get_error_message() << "] " << LOG_POS <<std::endl;
Psc::fail_fast();
}
// 映射
m_addr = mmap(nullptr, sizeof(MutexBlock), PROT_READ | PROT_WRITE, MAP_SHARED, m_fd, 0);
if (m_addr == MAP_FAILED) {
std::cout << "跨进程锁" << mutexName << "mmap失败 [" << get_error_message() << "] " << LOG_POS <<std::endl;
Psc::fail_fast();
}
auto block = static_cast<MutexBlock *>(m_addr);
if (creator) {
// 创建者初始化
memset(&block->mutex, 0, sizeof(pthread_mutex_t));
block->initialized.store(0, std::memory_order_relaxed);
pthread_mutexattr_t attr;
pthread_mutexattr_init(&attr);
pthread_mutexattr_setpshared(&attr, PTHREAD_PROCESS_SHARED);
pthread_mutexattr_setrobust(&attr, PTHREAD_MUTEX_ROBUST);
if (pthread_mutex_init(&block->mutex, &attr) != 0) {
pthread_mutexattr_destroy(&attr);
std::cout << "跨进程锁" << mutexName << "init失败 [" << get_error_message() << "] " << LOG_POS <<std::endl;
Psc::fail_fast();
}
pthread_mutexattr_destroy(&attr);
block->initialized.store(1, std::memory_order_release);
} else {
// 后来者等待初始化完成
auto ib = &block->initialized;
while (ib->load(std::memory_order_acquire) != 1) {
sched_yield();
}
}
}
Cross_Process_Mutex::~Cross_Process_Mutex() {
// if (m_addr) munmap(m_addr, sizeof(MutexBlock));
//
close(m_fd);
}
void Cross_Process_Mutex::lock() {
auto block = static_cast<MutexBlock *>(m_addr);
int r = pthread_mutex_lock(&block->mutex);
if (r == EOWNERDEAD) {
pthread_mutex_consistent(&block->mutex);
} else if (r == ENOTRECOVERABLE) {
throw std::runtime_error("mutex not recoverable");
} else if (r != 0) {
throw std::runtime_error("pthread_mutex_lock failed");
}
}
void Cross_Process_Mutex::unlock() {
auto block = static_cast<MutexBlock *>(m_addr);
pthread_mutex_unlock(&block->mutex);
}
void Cross_Process_Mutex::lock() {
auto block = static_cast<MutexBlock *>(m_addr);
int r = pthread_mutex_lock(&block->mutex);
if (r == EOWNERDEAD) {
pthread_mutex_consistent(&block->mutex);
} else if (r == ENOTRECOVERABLE) {
throw std::runtime_error("mutex not recoverable");
} else if (r != 0) {
throw std::runtime_error("pthread_mutex_lock failed");
}
}
void Cross_Process_Mutex::unlock() {
auto block = static_cast<MutexBlock *>(m_addr);
pthread_mutex_unlock(&block->mutex);
}
} // namespace Psc
#endif
Core/Shared_Memory/Shared_Memory_win.cpp
+138 -165
View File
@@ -2,172 +2,145 @@
#ifdef _WIN32
#include <Windows.h>
namespace Psc {
static std::string win_error_msg(DWORD err = GetLastError()) {
LPVOID lpMsgBuf;
FormatMessageA(
FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
NULL,
err,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
(LPSTR)&lpMsgBuf,
0, NULL);
static std::string win_error_msg(DWORD err = GetLastError()) {
LPVOID lpMsgBuf;
FormatMessageA(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM |
FORMAT_MESSAGE_IGNORE_INSERTS,
NULL, err, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
(LPSTR)&lpMsgBuf, 0, NULL);
std::string msg = (lpMsgBuf ? (char*)lpMsgBuf : "Unknown error");
if (lpMsgBuf) LocalFree(lpMsgBuf);
return msg;
}
Cross_Process_Mutex::Cross_Process_Mutex() : m_mutexHandle(nullptr) {
}
void Cross_Process_Mutex::init(const std::string &mutexName) {
m_mutexName = mutexName;
m_mutexHandle = OpenMutexA(MUTEX_ALL_ACCESS, FALSE, m_mutexName.c_str());
if (!m_mutexHandle) {
DWORD err = GetLastError();
if (err != ERROR_FILE_NOT_FOUND) {
std::cerr << "OpenMutexA failed: " << win_error_msg(err) << "\n";
}
m_mutexHandle = CreateMutexA(NULL, FALSE, m_mutexName.c_str());
if (!m_mutexHandle) {
std::cerr << "CreateMutexA failed: " << win_error_msg() << "\n";
Psc::fail_fast();
}
}
}
Cross_Process_Mutex::~Cross_Process_Mutex() {
if (m_mutexHandle != NULL) {
CloseHandle(m_mutexHandle);
}
}
void Cross_Process_Mutex::lock() {
DWORD waitResult = WaitForSingleObject(m_mutexHandle, INFINITE);
if (waitResult != WAIT_OBJECT_0) {
std::cerr << "WaitForSingleObject failed: " << win_error_msg() << "\n";
Psc::fail_fast();
}
}
// bool Cross_Process_Mutex::lock(DWORD dwMilliseconds) {
// DWORD waitResult = WaitForSingleObject(m_mutexHandle, dwMilliseconds);
// return (waitResult == WAIT_OBJECT_0);
// }
void Cross_Process_Mutex::unlock() {
if (!ReleaseMutex(m_mutexHandle)) {
std::cerr << "ReleaseMutex failed: " << win_error_msg() << "\n";
}
}
bool check_if_shared_memory_exists(const std::string &name) {
HANDLE hMapFile = OpenFileMappingA(FILE_MAP_READ, FALSE, name.c_str());
if (!hMapFile) {
DWORD err = GetLastError();
if (err != ERROR_FILE_NOT_FOUND) {
std::cerr << "OpenFileMappingA failed: " << win_error_msg(err)
<< " (checking existence for '" << name << "')\n";
}
return false;
}
CloseHandle(hMapFile);
return true;
}
Shared_Memory::~Shared_Memory()
{
close();
}
bool Shared_Memory::create(const std::string& name, size_t size)
{
std::cout << "创建共享内存【" << name << "】" << std::endl;
m_size = size;
m_handle = CreateFileMappingA(
INVALID_HANDLE_VALUE,
nullptr,
PAGE_READWRITE,
0,
(DWORD)size,
name.c_str()
);
if (!m_handle) {
std::cerr << "CreateFileMappingA failed for name=" << name
<< ": " << win_error_msg() << "\n";
return false;
}
m_ptr = MapViewOfFile(m_handle, FILE_MAP_ALL_ACCESS, 0, 0, size);
if (!m_ptr) {
std::cerr << "MapViewOfFile failed for name=" << name
<< ": " << win_error_msg() << "\n";
CloseHandle(m_handle);
m_handle = nullptr;
return false;
}
return true;
}
bool Shared_Memory::open(const std::string& name, size_t size)
{
std::cout << "打开共享内存【" << name << "】" << std::endl;
m_size = size;
m_handle = OpenFileMappingA(
FILE_MAP_ALL_ACCESS,
FALSE,
name.c_str()
);
if (!m_handle) {
std::cerr << "OpenFileMappingA failed for name=" << name
<< ": " << win_error_msg() << "\n";
return false;
}
m_ptr = MapViewOfFile(m_handle, FILE_MAP_ALL_ACCESS, 0, 0, size);
if (!m_ptr) {
std::cerr << "MapViewOfFile failed for name=" << name
<< ": " << win_error_msg() << "\n";
CloseHandle(m_handle);
m_handle = nullptr;
return false;
}
return true;
}
void Shared_Memory::close()
{
if (m_ptr) {
if (!UnmapViewOfFile(m_ptr)) {
std::cerr << "UnmapViewOfFile failed: " << win_error_msg() << "\n";
}
m_ptr = nullptr;
}
if (m_handle) {
if (!CloseHandle(m_handle)) {
std::cerr << "CloseHandle failed: " << win_error_msg() << "\n";
}
m_handle = nullptr;
}
}
void Shared_Memory::unlink()
{
// Windows 的共享内存对象在最后一个句柄关闭时自动销毁
// 不需要 shm_unlink 这种东西
std::string msg = (lpMsgBuf ? (char *)lpMsgBuf : "Unknown error");
if (lpMsgBuf)
LocalFree(lpMsgBuf);
return msg;
}
Cross_Process_Mutex::Cross_Process_Mutex() : m_mutexHandle(nullptr) {}
void Cross_Process_Mutex::init(const std::string &mutexName) {
m_mutexName = mutexName;
m_mutexHandle = OpenMutexA(MUTEX_ALL_ACCESS, FALSE, m_mutexName.c_str());
if (!m_mutexHandle) {
DWORD err = GetLastError();
if (err != ERROR_FILE_NOT_FOUND) {
std::cerr << "OpenMutexA failed: " << win_error_msg(err) << "\n";
}
m_mutexHandle = CreateMutexA(NULL, FALSE, m_mutexName.c_str());
if (!m_mutexHandle) {
std::cerr << "CreateMutexA failed: " << win_error_msg() << "\n";
Psc::fail_fast();
}
}
}
Cross_Process_Mutex::~Cross_Process_Mutex() {
if (m_mutexHandle != NULL) {
CloseHandle(m_mutexHandle);
}
}
void Cross_Process_Mutex::lock() {
DWORD waitResult = WaitForSingleObject(m_mutexHandle, INFINITE);
if (waitResult != WAIT_OBJECT_0) {
std::cerr << "WaitForSingleObject failed: " << win_error_msg() << "\n";
Psc::fail_fast();
}
}
// bool Cross_Process_Mutex::lock(DWORD dwMilliseconds) {
// DWORD waitResult = WaitForSingleObject(m_mutexHandle, dwMilliseconds);
// return (waitResult == WAIT_OBJECT_0);
// }
void Cross_Process_Mutex::unlock() {
if (!ReleaseMutex(m_mutexHandle)) {
std::cerr << "ReleaseMutex failed: " << win_error_msg() << "\n";
}
}
bool check_if_shared_memory_exists(const std::string &name) {
HANDLE hMapFile = OpenFileMappingA(FILE_MAP_READ, FALSE, name.c_str());
if (!hMapFile) {
DWORD err = GetLastError();
if (err != ERROR_FILE_NOT_FOUND) {
std::cerr << "OpenFileMappingA failed: " << win_error_msg(err)
<< " (checking existence for '" << name << "')\n";
}
return false;
}
CloseHandle(hMapFile);
return true;
}
Shared_Memory::~Shared_Memory() { close(); }
bool Shared_Memory::create(const std::string &name, size_t size) {
std::cout << "创建共享内存【" << name << "】" << std::endl;
m_size = size;
m_handle = CreateFileMappingA(INVALID_HANDLE_VALUE, nullptr, PAGE_READWRITE,
0, (DWORD)size, name.c_str());
if (!m_handle) {
std::cerr << "CreateFileMappingA failed for name=" << name << ": "
<< win_error_msg() << "\n";
return false;
}
m_ptr = MapViewOfFile(m_handle, FILE_MAP_ALL_ACCESS, 0, 0, size);
if (!m_ptr) {
std::cerr << "MapViewOfFile failed for name=" << name << ": "
<< win_error_msg() << "\n";
CloseHandle(m_handle);
m_handle = nullptr;
return false;
}
return true;
}
bool Shared_Memory::open(const std::string &name, size_t size) {
std::cout << "打开共享内存【" << name << "】" << std::endl;
m_size = size;
m_handle = OpenFileMappingA(FILE_MAP_ALL_ACCESS, FALSE, name.c_str());
if (!m_handle) {
std::cerr << "OpenFileMappingA failed for name=" << name << ": "
<< win_error_msg() << "\n";
return false;
}
m_ptr = MapViewOfFile(m_handle, FILE_MAP_ALL_ACCESS, 0, 0, size);
if (!m_ptr) {
std::cerr << "MapViewOfFile failed for name=" << name << ": "
<< win_error_msg() << "\n";
CloseHandle(m_handle);
m_handle = nullptr;
return false;
}
return true;
}
void Shared_Memory::close() {
if (m_ptr) {
if (!UnmapViewOfFile(m_ptr)) {
std::cerr << "UnmapViewOfFile failed: " << win_error_msg() << "\n";
}
m_ptr = nullptr;
}
if (m_handle) {
if (!CloseHandle(m_handle)) {
std::cerr << "CloseHandle failed: " << win_error_msg() << "\n";
}
m_handle = nullptr;
}
}
void Shared_Memory::unlink() {
// Windows 的共享内存对象在最后一个句柄关闭时自动销毁
// 不需要 shm_unlink 这种东西
}
} // namespace Psc
#endif