hpc_common.hpp

里面有一些好用的函数。

#pragma once
#include <new>
#include <iostream>
#include <vector>
#include <stdint.h>
#include <stddef.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <ftw.h>
#include <sys/mman.h>
#include <sys/mman.h>
#include <pthread.h>
#include <sched.h>
#include <signal.h>






namespace hpc_common {



/*********************** simple debug_print ********************************/
/*
#define DEBUG_LEVEL_INFO

#ifndef debug_info
#   if defined(DEBUG_LEVEL_INFO)
#       define debug_info(...)  do { printf("[line%d:%s] debug_info: ", __LINE__, __func__);  printf(__VA_ARGS__); printf("\n");} while(0)
#   else
#       define debug_info(...)  ((void) 0)
#   endif
#endif
*/



/*********************** debug_print ********************************/
#define DEBUG_LEVEL_INFO
#define DEBUG_LEVEL_WARNING
#define DEBUG_LEVEL_ERROR

#define DEBUG_COLOR_PRINT

#ifdef DEBUG_COLOR_PRINT
    #define DEBUG_COLOR_RED     "\033[31m"
    #define DEBUG_COLOR_GREEN   "\033[32m"
    #define DEBUG_COLOR_YELLOW  "\033[33m"
    #define DEBUG_COLOR_BLUE    "\033[34m"
    #define DEBUG_COLOR_PURPLE  "\033[35m"
    #define DEBUG_COLOR_RESET   "\033[m"
#else
    #define DEBUG_COLOR_RED 
    #define DEBUG_COLOR_GREEN 
    #define DEBUG_COLOR_YELLOW 
    #define DEBUG_COLOR_BLUE 
    #define DEBUG_COLOR_PURPLE 
    #define DEBUG_COLOR_RESET 
#endif



#ifndef filename_strip_path
#define filename_strip_path(x) strrchr(x,'/')?strrchr(x,'/')+1:x
#endif

#ifndef debug_prefix
#define debug_prefix(tag,color)  printf(color "[%s:%d:%s]: " tag DEBUG_COLOR_RESET, filename_strip_path(__FILE__), __LINE__, __func__)
#endif


#ifndef debug_info
#if  defined(DEBUG_LEVEL_INFO)
#  define debug_info(...)  do { debug_prefix("debug_info: ",     DEBUG_COLOR_GREEN);  printf(__VA_ARGS__); printf("\n");fflush(stdout);} while(0)
#else
#  define debug_info(...)  ((void) 0)
#endif
#endif


#ifndef debug_warning
#if defined(DEBUG_LEVEL_WARNING)
#  define debug_warning(...)    do { debug_prefix("debug_warning: ", DEBUG_COLOR_YELLOW); printf(__VA_ARGS__); printf("\n");fflush(stdout); } while(0)
#else
#  define debug_warning(...)    ((void) 0)
#endif
#endif


#ifndef debug_error
#if defined(DEBUG_LEVEL_ERROR)
#  define debug_error(...)    do { debug_prefix("debug_error: ",   DEBUG_COLOR_RED);    printf(__VA_ARGS__); printf("\n");fflush(stdout); } while(0)
#else
#  define debug_error(...)    ((void) 0)
#endif
#endif


#ifndef debug_assert
#if defined(DEBUG_LEVEL_ERROR)
#  define debug_assert(expr, ...)    do { if (!(expr)) { debug_prefix("debug_assert fail: ", DEBUG_COLOR_PURPLE); \
    printf(DEBUG_COLOR_PURPLE " [" #expr "] " DEBUG_COLOR_RESET); printf(__VA_ARGS__); printf("\n"); fflush(stdout); exit(-1); } } while(0)
#else
#  define debug_assert(...)     ((void) 0)
#endif
#endif




static inline void debug_print_16x_data(const uint8_t *data, int len) {
#ifdef DEBUG_LEVEL_INFO
    int i=0;
    while(1){
        for(int t=0; t<16; ++t) {
            if(i==len) {
                printf("\n");
                return;
            }
            printf("%02x ", *data);
            data++;
            i++;
        }
        printf("\n");
    }
#endif
}






/*********************** print ********************************/

#ifndef print_info
#define print_info(...)    do { debug_prefix("print_info: ", DEBUG_COLOR_GREEN); printf(__VA_ARGS__); printf("\n");} while(0)
#endif

#ifndef print_warning
#define print_warning(...)    do { debug_prefix("print_warning: ", DEBUG_COLOR_YELLOW); printf(__VA_ARGS__); printf("\n"); } while(0)
#endif

#ifndef print_error
#define print_error(...)    do { debug_prefix("print_error: ",   DEBUG_COLOR_RED);  \
    printf(__VA_ARGS__);  printf(" , errno=%d, errstr: %s\n",errno,strerror(errno)); exit(errno);} while(0)
#endif

#ifndef error_exit
#define error_exit(...)    do { debug_prefix("error_exit: ",   DEBUG_COLOR_RED);   \
    printf(__VA_ARGS__);  printf(" , errno=%d, errstr: %s\n",errno,strerror(errno)); exit(errno);} while(0)
#endif













/*********************** macro / bit ********************************/

#define _MACRO_TO_STR_AUX(macro) #macro
#define MACRO_TO_STR(macro) _MACRO_TO_STR_AUX(macro)


// align should be power of 2, like 1024
#define HPC_ROUND_UP(value, align)  (((value) + ((align)-1u)) & ~((align)-1u))
#define HPC_ROUND_DOWN(value, align)  ((value) & ~((align)-1u))
#define HPC_IS_POWER2(value)		((value) > 0 && (((value) & (~(value) + 1u)) == (value)))












/*********************** atomic ********************************/

#ifndef mem_barrier
#define mem_barrier() do { __asm__ __volatile__("" : : : "cc", "memory" ); } while(0)
#endif

#ifndef cpu_barrier
#define cpu_barrier() do { __asm__ __volatile__("lock" : addl $0 0(%%esp) : : "cc", "memory" ); } while(0)
#endif


#ifndef mem_read
#define mem_read(var) do { __asm__ __volatile__("" : "=m"(var) : :); } while(0)
#endif

#ifndef memory_write
#define memory_write(var) do { __asm__ __volatile__("" : : "m"(var) : ); } while(0)
#endif





















/*********************** string ********************************/

template<typename... Args>
std::string string_sprintf(const char* format, Args... args) {
    char buf[4096];
    std::snprintf(buf, 4096, format, args...);
    std::string str(buf);
    return std::move(str);
}
















/*********************** memory mmap ********************************/

//touch mm page to tlb
static inline void hpc_touch_pages(void *base, size_t len, size_t page_size)
{
    for (uint i = 0; i < len; i += page_size)   {
        volatile uint8_t &byte = *((volatile uint8_t *)base + i);
        __asm__ __volatile__("" : : "m"(byte) : );
    }
}

static inline void* hpc_mmap(int fd, size_t len)
{
    int flags = MAP_SHARED;
    // if (huge_page)  {
    //     // flags = MAP_SHARED | MAP_HUGETLB;
    // }
    auto ret = mmap(NULL, len, PROT_READ | PROT_WRITE, flags, fd, 0);
    close(fd);
    return ret;
}


static inline int hpc_unmap(void *addr, size_t len)
{
    if (NULL != addr) {
        return munmap(addr, len);
    }
    return 0;
}


/**
 * max msglen 1042;
 * usage:     
 *   try {
 *       int aa = 5;
 *       throw HpcException("some thing wrong: aa=%d", aa);
 *   }
 *   catch(HpcException e) {
 *       printf("catch exception: %s\n", e.what());
 *   }
**/
class HpcException: std::exception {
public:
    template<typename... Args>
    explicit HpcException(const char* format, Args... args) throw() {
        constexpr int msglen = 4096;
        char buf[msglen];
        std::snprintf(buf, msglen, format, args...);
        what_.assign(buf);
    }
    const char* what() const throw()
    {
        return what_.c_str();
    }
private:
    std::string what_;
};



// is_new will be set true if the file is new created, else false.
// return map addr.
static inline void * hpc_map_new_or_exist(const char *path, size_t len, bool &is_new)
{
    is_new = true;
    int fd = open(path, (O_CREAT | O_EXCL | O_RDWR), 0700);
    if (fd<0) {
        is_new = false;
    }

    fd = open(path, (O_CREAT | O_RDWR), 0700);
    if (fd<0)  throw shm_bad_alloc("file open error, path=%s, len=%lu, lasterr=%s", path, len, strerror(errno));

    if (ftruncate(fd, (off_t)len) < 0) {
        throw shm_bad_alloc("file ftruncate error, path=%s, len=%lu, lasterr=%s", path, len, strerror(errno));
    }
    
    auto ret = hpc_mmap(fd, len);
    if (ret == MAP_FAILED) {
        throw shm_bad_alloc("file mmap error, path=%s, len=%lu, lasterr=%s", path, len, strerror(errno));
    }
    if (is_new)  memset(ret, 0, len);
    else hpc_touch_pages(ret, len, 4096);
    return ret;
}


// open or create file, and reset to 0.
static inline void * hpc_map_new(const char *path, size_t len)
{
    //create, rewrite.
    int fd = open(path, O_RDWR | O_CREAT, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH);
    // debug_info("fd = %d\n", fd);
    if (fd<0)  throw shm_bad_alloc("file open error, path=%s, len=%lu", path, len);

    if (ftruncate(fd, (off_t)len) < 0)
        throw shm_bad_alloc("file ftruncate error, path=%s, len=%lu", path, len);
    
    auto ret = hpc_mmap(fd, len);
    if (ret == MAP_FAILED)
        throw shm_bad_alloc("mmap error, path=%s, len=%lu, lasterr=%s", path, len, strerror(errno));

    memset(ret, 0, len);
    // hpc_touch_pages(ret, len, 4096);
    return ret;
}

static inline void * hpc_map_exist(const char *path, size_t len)
{
	// debug_info("path=%s\n", path);
    
    int fd = open(path, O_RDWR);
    if(fd<0) 
        throw shm_bad_alloc("open file fail: %s", path);
    
    struct stat sb;
    if (fstat(fd, &sb) != 0)
        throw shm_bad_alloc("get fstat fail: fd=%d, file=%s", fd, path);

    auto ret_addr = hpc_mmap(fd, len);
    if (ret_addr == MAP_FAILED)
        throw shm_bad_alloc("mmap fail: file=%s, map_len=%lu, fd=%d", path, len, fd);
        
    hpc_touch_pages(ret_addr, len, 4096);
    return ret_addr;
}






















/*********************** time performance ********************************/

static inline uint64_t rdtsc() {
    uint32_t lo, hi;
    __asm__ volatile("rdtsc" : "=a"(lo), "=d"(hi) : :);
    return (uint64_t)hi<<32|lo;
    //return __builtin_ia32_rdtsc();
}

static inline int64_t get_nano_clock()
{
    struct timespec ts;
    if (clock_gettime(CLOCK_MONOTONIC, &ts) < 0) {
        return -1;
    }

    return ((int64_t)ts.tv_sec * 1000000000) + ts.tv_nsec;
}


//int us may cause overflow bug.
void usleep_inwhile(int64_t us) {
    timespec ts;
    clock_gettime(CLOCK_REALTIME, &ts);
    int64_t start_ns = ts.tv_sec*1000000000+ts.tv_nsec;
    int64_t end_ns = start_ns + us*1000;
    while(1) {
        clock_gettime(CLOCK_REALTIME, &ts);
        if(ts.tv_sec*1000000000+ts.tv_nsec > end_ns) {
            break;
        }
    }
}














/*********************** system ********************************/

inline void set_thread_affinity(uint32_t cpu_id)
{

    if (cpu_id < 0)
        return;

    cpu_set_t cpuset;
    CPU_ZERO(&cpuset);
    CPU_SET(cpu_id, &cpuset);

    if(-1 == pthread_setaffinity_np(pthread_self(), sizeof(cpuset), &cpuset)) {
        print_error("set thread affinity fail, cpu_id=%u", cpu_id);
        return;
    }
}


inline void SetCpuAffinity(uint32_t cpu_id)
{
    if (cpu_id < 0)
        return;

    cpu_set_t cpuset;
    CPU_ZERO(&cpuset);
    CPU_SET(cpu_id, &cpuset);

    if(sched_setaffinity(0, sizeof(cpuset), &cpuset) == -1){
        print_error("set cpu affinity fail, cpu_id=%u", cpu_id);
        return;
    }
}


//popen print to stdout
static inline pid_t popen_tostd(const char *cmd){
    pid_t pid = fork();
    if(pid!=0) {
        return pid;
    }
    char _cmd[512]{0};
    sprintf(_cmd, "%s", cmd);
    execl("/bin/sh", "sh", "-c", _cmd, NULL);
    exit(0); //will never get here.
}

static inline void Signal(int signum, sighandler_t handler) {
    struct sigaction action, old_action;
    action.sa_handler = handler;
    sigemptyset(&action.sa_mask);
    sigaddset(&action.sa_mask, signum);
    action.sa_flags = SA_RESTART;
    
    if(sigaction(signum, &action, &old_action) < 0) {
        fprintf(stderr, "sigaction error, signum=%d, errno=%s", signum, strerror(errno));
    }
}



















/*********************** bits ********************************/

static inline constexpr bool is_power_of_2(size_t num) {
    return (num >= 2) && ((num & (num - 1)) == 0);
} 












































/*********************** list ********************************/

/**
--ring list: h--n1--n2--h

struct SS *g_ss_list = new SS;

list_head *p, *pnext;
list_for_each_safe(p, pnext, &g_ss_list) {
    if(p->xxx)
        list_del(p);
}

attention: do not add the same node twice to one list.
****/


#define init_list_head(ptr) do { \
	(ptr)->next = (ptr); (ptr)->prev = (ptr); \
} while (0)

#define list_entry(ptr, type, member) \
	((type *)((char *)(ptr)-(unsigned long)(&((type *)0)->member)))

#define list_for_each(pos, head) \
	for (pos = (head)->next; pos != (head); \
        	pos = pos->next)
#define list_for_each_prev(pos, head) \
	for (pos = (head)->prev; pos != (head); \
        	pos = pos->prev)

// can list_del(p) safely
#define list_for_each_safe(pos, n, head) \
	for (pos = (head)->next, n = pos->next; pos != (head); \
		pos = n, n = pos->next)


#define list_for_each_safe_reverse(pos, n, head) \
	for (pos = (head)->prev, n = pos->prev; pos != (head); \
		pos = n, n = pos->prev)


#define list_for_each_entry(pos, head, member)				\
	for (pos = list_entry((head)->next, typeof(*pos), member);	\
	     &pos->member != (head); 					\
	     pos = list_entry(pos->member.next, typeof(*pos), member))

#define list_for_each_entry_safe(pos, n, head, member)			\
	for (pos = list_entry((head)->next, typeof(*pos), member),	\
		n = list_entry(pos->member.next, typeof(*pos), member);	\
	     &pos->member != (head); 					\
	     pos = n, n = list_entry(n->member.next, typeof(*n), member))


template<typename list_head>
static inline void __list_add(list_head *newl, list_head *prev, list_head *next)
{
	newl->next = next;
	newl->prev = prev;
	next->prev = newl;
	prev->next = newl;
}


// add after:  h--n1--n2--h   =>     h--newl--n1--n2--h
template<typename list_head>
static inline void list_add(list_head *head, list_head *newl)
{
	__list_add(newl, head, head->next);
}


// add to tail: h--n1--n2--h   =>     h--n1--n2--newl--h
template<typename list_head>
static inline void list_add_tail(list_head *head, list_head *newl)
{
	__list_add(newl, head->prev, head);
}


// same as list_add_tail
template<typename list_head>
static inline void list_add_before(list_head *cur, list_head *newl)
{
	__list_add(newl, cur->prev, cur);
}


template<typename list_head>
static inline void __list_del(list_head *prev, list_head *next)
{
	next->prev = prev;
	prev->next = next;
}


//remove from list
template<typename list_head>
static inline void list_del(list_head *entry)
{
    // list_head->inuse = false;
	__list_del(entry->prev, entry->next);
	entry->next = NULL;
	entry->prev = (list_head *) 0;
}


template<typename list_head>
static inline void list_del_init(list_head *entry)
{
	__list_del(entry->prev, entry->next);
	INIT_LIST_HEAD(entry); 
}


template<typename list_head>
static inline void list_move(list_head *list, list_head *head)
{
    __list_del(list->prev, list->next);
    list_add(list, head);
}


template<typename list_head>
static inline void list_move_tail(list_head *list, list_head *head)
{
    __list_del(list->prev, list->next);
    list_add_tail(list, head);
}


template<typename list_head>
static inline int list_empty(list_head *head)
{
	return head->next == head;
}


template<typename list_head>
static inline void __list_splice(list_head *list, list_head *head)
{
	list_head *first = list->next;
	list_head *last = list->prev;
	list_head *at = head->next;

	first->prev = head;
	head->next = first;

	last->next = at;
	at->prev = last;
}


template<typename list_head>
static inline void list_splice(list_head *list, list_head *head)
{
	if (!list_empty(list)) {
		__list_splice(list, head);
	}
}


template<typename list_head>
static inline void list_splice_init(list_head *list, list_head *head)
{
	if (!list_empty(list)) {
		__list_splice(list, head);
		INIT_LIST_HEAD(list);
	}
}


// template<typename T>
// void __list_insert(T *neww, T *prev, T *next){
//     if(next)
//         next->prev = neww;

//     // neww should not be null
//     neww->next = next;
//     neww->prev = prev;

//     if(prev)
//         prev->next = neww;
// }

// template<typename T>
// void list_insert_after(T *cur, T *neww){
//     __list_insert(neww, cur, cur->next);
// }


// template<typename T>
// void list_insert_before(T *cur, T *neww){
//     __list_insert(neww, cur->prev, cur);
// }

// //do not change cur.
// template<typename T>
// void list_remove(T *cur){
//     if(cur->prev)
//         cur->prev->next = cur->next;
        
//     if(cur->next)
//         cur->next->prev = cur->prev;
// }













/*********************** file ********************************/

template<typename... Args>
static inline std::string get_first_exist_file(Args ...args)
{
    std::vector<std::string> filenames{args...};
    for(auto p = filenames.begin(); p != filenames.end(); ++p) {
        if(fopen(p->c_str(), "r"))
            return *p;
    }
    return std::string();
}



} //end of namespace hpc_common