liblfds对基本数据类型的封装

最新推荐文章于 2020-08-26 17:23:22 发布
最新推荐文章于 2020-08-26 17:23:22 发布
阅读量1.3k 收藏
点赞数
分类专栏： 代码收藏 
#ifndef __LIBLFDS611_H

  /***** library header *****/
  #define LFDS611_RELEASE_NUMBER_STRING  "6.1.1"




  /***** lfds611_abstraction *****/

  /***** defines *****/
  #if (defined _WIN64 && defined _MSC_VER && !defined WIN_KERNEL_BUILD)
    // TRD : 64-bit Windows user-mode with the Microsoft C compiler, any CPU
    #include <assert.h>
    #include <stdio.h>
    #include <stdlib.h>
    #include <windows.h>
    #include <intrin.h>
    typedef unsigned __int64                 lfds611_atom_t;
    #define LFDS611_INLINE                   __forceinline
    #define LFDS611_ALIGN(alignment)         __declspec( align(alignment) )
    #define LFDS611_ALIGN_SINGLE_POINTER     8
    #define LFDS611_ALIGN_DOUBLE_POINTER     16
    #define LFDS611_BARRIER_COMPILER_LOAD    _ReadBarrier()
    #define LFDS611_BARRIER_COMPILER_STORE   _WriteBarrier()
    #define LFDS611_BARRIER_COMPILER_FULL    _ReadWriteBarrier()
    #define LFDS611_BARRIER_PROCESSOR_LOAD   _mm_lfence()
    #define LFDS611_BARRIER_PROCESSOR_STORE  _mm_sfence()
    #define LFDS611_BARRIER_PROCESSOR_FULL   _mm_mfence()
  #endif

  #if (!defined _WIN64 && defined _WIN32 && defined _MSC_VER && !defined WIN_KERNEL_BUILD)
    // TRD : 32-bit Windows user-mode with the Microsoft C compiler, any CPU
    #include <assert.h>
    #include <stdio.h>
    #include <stdlib.h>
    #include <windows.h>
    #include <intrin.h>
    typedef unsigned long int                lfds611_atom_t;
    #define LFDS611_INLINE                   __forceinline
    #define LFDS611_ALIGN(alignment)         __declspec( align(alignment) )
    #define LFDS611_ALIGN_SINGLE_POINTER     4
    #define LFDS611_ALIGN_DOUBLE_POINTER     8
    #define LFDS611_BARRIER_COMPILER_LOAD    _ReadBarrier()
    #define LFDS611_BARRIER_COMPILER_STORE   _WriteBarrier()
    #define LFDS611_BARRIER_COMPILER_FULL    _ReadWriteBarrier()
    #define LFDS611_BARRIER_PROCESSOR_LOAD   _mm_lfence()
    #define LFDS611_BARRIER_PROCESSOR_STORE  _mm_sfence()
    #define LFDS611_BARRIER_PROCESSOR_FULL   _mm_mfence()

    // TRD : this define is documented but missing in Microsoft Platform SDK v7.0
    #define _InterlockedCompareExchangePointer(destination, exchange, compare) _InterlockedCompareExchange((volatile long *) destination, (long) exchange, (long) compare)
  #endif

  #if (defined _WIN64 && defined _MSC_VER && defined WIN_KERNEL_BUILD)
    // TRD : 64-bit Windows kernel with the Microsoft C compiler, any CPU
    #include <assert.h>
    #include <stdio.h>
    #include <stdlib.h>
    #include <wdm.h>
    typedef unsigned __int64                 lfds611_atom_t;
    #define LFDS611_INLINE                   __forceinline
    #define LFDS611_ALIGN(alignment)         __declspec( align(alignment) )
    #define LFDS611_ALIGN_SINGLE_POINTER     8
    #define LFDS611_ALIGN_DOUBLE_POINTER     16
    #define LFDS611_BARRIER_COMPILER_LOAD    _ReadBarrier()
    #define LFDS611_BARRIER_COMPILER_STORE   _WriteBarrier()
    #define LFDS611_BARRIER_COMPILER_FULL    _ReadWriteBarrier()
    #define LFDS611_BARRIER_PROCESSOR_LOAD   _mm_lfence()
    #define LFDS611_BARRIER_PROCESSOR_STORE  _mm_sfence()
    #define LFDS611_BARRIER_PROCESSOR_FULL   _mm_mfence()
  #endif

  #if (!defined _WIN64 && defined _WIN32 && defined _MSC_VER && defined WIN_KERNEL_BUILD)
    // TRD : 32-bit Windows kernel with the Microsoft C compiler, any CPU
    #include <assert.h>
    #include <stdio.h>
    #include <stdlib.h>
    #include <wdm.h>
    typedef unsigned long int                lfds611_atom_t;
    #define LFDS611_INLINE                   __forceinline
    #define LFDS611_ALIGN(alignment)         __declspec( align(alignment) )
    #define LFDS611_ALIGN_SINGLE_POINTER     4
    #define LFDS611_ALIGN_DOUBLE_POINTER     8
    #define LFDS611_BARRIER_COMPILER_LOAD    _ReadBarrier()
    #define LFDS611_BARRIER_COMPILER_STORE   _WriteBarrier()
    #define LFDS611_BARRIER_COMPILER_FULL    _ReadWriteBarrier()
    #define LFDS611_BARRIER_PROCESSOR_LOAD   _mm_lfence()
    #define LFDS611_BARRIER_PROCESSOR_STORE  _mm_sfence()
    #define LFDS611_BARRIER_PROCESSOR_FULL   _mm_mfence()

    // TRD : this define is documented but missing in Microsoft Platform SDK v7.0
    #define _InterlockedCompareExchangePointer(destination, exchange, compare) _InterlockedCompareExchange((volatile long *) destination, (long) exchange, (long) compare)
  #endif

  #if (defined __unix__ && defined __x86_64__ && __GNUC__)
    // TRD : any UNIX with GCC on x64
    #include <assert.h>
    #include <stdio.h>
    #include <stdlib.h>
    typedef unsigned long long int           lfds611_atom_t;
    #define LFDS611_INLINE                   inline
    #define LFDS611_ALIGN(alignment)         __attribute__( (aligned(alignment)) )
    #define LFDS611_ALIGN_SINGLE_POINTER     8
    #define LFDS611_ALIGN_DOUBLE_POINTER     16
    #define LFDS611_BARRIER_COMPILER_LOAD    __asm__ __volatile__ ( "" : : : "memory" )
    #define LFDS611_BARRIER_COMPILER_STORE   __asm__ __volatile__ ( "" : : : "memory" )
    #define LFDS611_BARRIER_COMPILER_FULL    __asm__ __volatile__ ( "" : : : "memory" )
    #define LFDS611_BARRIER_PROCESSOR_LOAD   __sync_synchronize()
    #define LFDS611_BARRIER_PROCESSOR_STORE  __sync_synchronize()
    #define LFDS611_BARRIER_PROCESSOR_FULL   __sync_synchronize()
  #endif

  #if (defined __unix__ && defined __i686__ && __GNUC__)
    // TRD : any UNIX with GCC on x86
    #include <assert.h>
    #include <stdio.h>
    #include <stdlib.h>
    typedef unsigned long int                lfds611_atom_t;
    #define LFDS611_INLINE                   inline
    #define LFDS611_ALIGN(alignment)         __attribute__( (aligned(alignment)) )
    #define LFDS611_ALIGN_SINGLE_POINTER     4
    #define LFDS611_ALIGN_DOUBLE_POINTER     8
    #define LFDS611_BARRIER_COMPILER_LOAD    __asm__ __volatile__ ( "" : : : "memory" )
    #define LFDS611_BARRIER_COMPILER_STORE   __asm__ __volatile__ ( "" : : : "memory" )
    #define LFDS611_BARRIER_COMPILER_FULL    __asm__ __volatile__ ( "" : : : "memory" )
    #define LFDS611_BARRIER_PROCESSOR_LOAD   __sync_synchronize()
    #define LFDS611_BARRIER_PROCESSOR_STORE  __sync_synchronize()
    #define LFDS611_BARRIER_PROCESSOR_FULL   __sync_synchronize()
  #endif

  #if (defined __unix__ && defined __arm__ && __GNUC__)
    // TRD : any UNIX with GCC on ARM
    #include <assert.h>
    #include <stdio.h>
    #include <stdlib.h>
    typedef unsigned long int                lfds611_atom_t;
    #define LFDS611_INLINE                   inline
    #define LFDS611_ALIGN(alignment)         __attribute__( (aligned(alignment)) )
    #define LFDS611_ALIGN_SINGLE_POINTER     4
    #define LFDS611_ALIGN_DOUBLE_POINTER     8
    #define LFDS611_BARRIER_COMPILER_LOAD    __asm__ __volatile__ ( "" : : : "memory" )
    #define LFDS611_BARRIER_COMPILER_STORE   __asm__ __volatile__ ( "" : : : "memory" )
    #define LFDS611_BARRIER_COMPILER_FULL    __asm__ __volatile__ ( "" : : : "memory" )
    #define LFDS611_BARRIER_PROCESSOR_LOAD   __sync_synchronize()
    #define LFDS611_BARRIER_PROCESSOR_STORE  __sync_synchronize()
    #define LFDS611_BARRIER_PROCESSOR_FULL   __sync_synchronize()
  #endif

  #define LFDS611_BARRIER_LOAD   LFDS611_BARRIER_COMPILER_LOAD; LFDS611_BARRIER_PROCESSOR_LOAD; LFDS611_BARRIER_COMPILER_LOAD
  #define LFDS611_BARRIER_STORE  LFDS611_BARRIER_COMPILER_STORE; LFDS611_BARRIER_PROCESSOR_STORE; LFDS611_BARRIER_COMPILER_STORE
  #define LFDS611_BARRIER_FULL   LFDS611_BARRIER_COMPILER_FULL; LFDS611_BARRIER_PROCESSOR_FULL; LFDS611_BARRIER_COMPILER_FULL

  /***** enums *****/
  enum lfds611_data_structure_validity
  {
    LFDS611_VALIDITY_VALID,
    LFDS611_VALIDITY_INVALID_LOOP,
    LFDS611_VALIDITY_INVALID_MISSING_ELEMENTS,
    LFDS611_VALIDITY_INVALID_ADDITIONAL_ELEMENTS,
    LFDS611_VALIDITY_INVALID_TEST_DATA
  };

  /***** structs *****/
  struct lfds611_validation_info
  {
    lfds611_atom_t
      min_elements,
      max_elements;
  };

  /***** public prototypes *****/
  void *lfds611_abstraction_malloc( size_t size );
  void lfds611_abstraction_free( void *memory );





  /***** lfds611_freelist *****/

  /***** enums *****/
  enum lfds611_freelist_query_type
  {
    LFDS611_FREELIST_QUERY_ELEMENT_COUNT,
    LFDS611_FREELIST_QUERY_VALIDATE
  };

  /***** incomplete types *****/
  struct lfds611_freelist_state;
  struct lfds611_freelist_element;

  /***** public prototypes *****/
  int lfds611_freelist_new( struct lfds611_freelist_state **fs, lfds611_atom_t number_elements, int (*user_data_init_function)(void **user_data, void *user_state), void *user_state );
  void lfds611_freelist_use( struct lfds611_freelist_state *fs );
  void lfds611_freelist_delete( struct lfds611_freelist_state *fs, void (*user_data_delete_function)(void *user_data, void *user_state), void *user_state );

  lfds611_atom_t lfds611_freelist_new_elements( struct lfds611_freelist_state *fs, lfds611_atom_t number_elements );

  struct lfds611_freelist_element *lfds611_freelist_pop( struct lfds611_freelist_state *fs, struct lfds611_freelist_element **fe );
  struct lfds611_freelist_element *lfds611_freelist_guaranteed_pop( struct lfds611_freelist_state *fs, struct lfds611_freelist_element **fe );
  void lfds611_freelist_push( struct lfds611_freelist_state *fs, struct lfds611_freelist_element *fe );

  void *lfds611_freelist_get_user_data_from_element( struct lfds611_freelist_element *fe, void **user_data );
  void lfds611_freelist_set_user_data_in_element( struct lfds611_freelist_element *fe, void *user_data );

  void lfds611_freelist_query( struct lfds611_freelist_state *fs, enum lfds611_freelist_query_type query_type, void *query_input, void *query_output );





  /***** lfds611_liblfds *****/

  /***** public prototypes *****/
  void lfds611_liblfds_abstraction_test_helper_increment_non_atomic( lfds611_atom_t *shared_counter );
  void lfds611_liblfds_abstraction_test_helper_increment_atomic( volatile lfds611_atom_t *shared_counter );
  void lfds611_liblfds_abstraction_test_helper_cas( volatile lfds611_atom_t *shared_counter, lfds611_atom_t *local_counter );
  void lfds611_liblfds_abstraction_test_helper_dcas( volatile lfds611_atom_t *shared_counter, lfds611_atom_t *local_counter );





  /***** lfds611_queue *****/

  /***** enums *****/
  enum lfds611_queue_query_type
  {
    LFDS611_QUEUE_QUERY_ELEMENT_COUNT,
    LFDS611_QUEUE_QUERY_VALIDATE
  };

  /***** incomplete types *****/
  struct lfds611_queue_state;

  /***** public prototypes *****/
  int lfds611_queue_new( struct lfds611_queue_state **sq, lfds611_atom_t number_elements );
  void lfds611_queue_use( struct lfds611_queue_state *qs );
  void lfds611_queue_delete( struct lfds611_queue_state *qs, void (*user_data_delete_function)(void *user_data, void *user_state), void *user_state );

  int lfds611_queue_enqueue( struct lfds611_queue_state *qs, void *user_data );
  int lfds611_queue_guaranteed_enqueue( struct lfds611_queue_state *qs, void *user_data );
  int lfds611_queue_dequeue( struct lfds611_queue_state *qs, void **user_data );

  void lfds611_queue_query( struct lfds611_queue_state *qs, enum lfds611_queue_query_type query_type, void *query_input, void *query_output );





  /***** lfds611_ringbuffer *****/

  /***** enums *****/
  enum lfds611_ringbuffer_query_type
  {
    LFDS611_RINGBUFFER_QUERY_VALIDATE
  };

  /***** incomplete types *****/
  struct lfds611_ringbuffer_state;

  /***** public prototypes *****/
  int lfds611_ringbuffer_new( struct lfds611_ringbuffer_state **rs, lfds611_atom_t number_elements, int (*user_data_init_function)(void **user_data, void *user_state), void *user_state );
  void lfds611_ringbuffer_use( struct lfds611_ringbuffer_state *rs );
  void lfds611_ringbuffer_delete( struct lfds611_ringbuffer_state *rs, void (*user_data_delete_function)(void *user_data, void *user_state), void *user_state );

  struct lfds611_freelist_element *lfds611_ringbuffer_get_read_element( struct lfds611_ringbuffer_state *rs, struct lfds611_freelist_element **fe );
  struct lfds611_freelist_element *lfds611_ringbuffer_get_write_element( struct lfds611_ringbuffer_state *rs, struct lfds611_freelist_element **fe, int *overwrite_flag );

  void lfds611_ringbuffer_put_read_element( struct lfds611_ringbuffer_state *rs, struct lfds611_freelist_element *fe );
  void lfds611_ringbuffer_put_write_element( struct lfds611_ringbuffer_state *rs, struct lfds611_freelist_element *fe );

  void lfds611_ringbuffer_query( struct lfds611_ringbuffer_state *rs, enum lfds611_ringbuffer_query_type query_type, void *query_input, void *query_output );





  /***** lfds611_slist *****/

  /***** incomplete types *****/
  struct lfds611_slist_state;
  struct lfds611_slist_element;

  /***** public prototypes *****/
  int lfds611_slist_new( struct lfds611_slist_state **ss, void (*user_data_delete_function)(void *user_data, void *user_state), void *user_state );
  void lfds611_slist_use( struct lfds611_slist_state *ss );
  void lfds611_slist_delete( struct lfds611_slist_state *ss );

  struct lfds611_slist_element *lfds611_slist_new_head( struct lfds611_slist_state *ss, void *user_data );
  struct lfds611_slist_element *lfds611_slist_new_next( struct lfds611_slist_element *se, void *user_data );

  int lfds611_slist_logically_delete_element( struct lfds611_slist_state *ss, struct lfds611_slist_element *se );
  void lfds611_slist_single_threaded_physically_delete_all_elements( struct lfds611_slist_state *ss );

  int lfds611_slist_get_user_data_from_element( struct lfds611_slist_element *se, void **user_data );
  int lfds611_slist_set_user_data_in_element( struct lfds611_slist_element *se, void *user_data );

  struct lfds611_slist_element *lfds611_slist_get_head( struct lfds611_slist_state *ss, struct lfds611_slist_element **se );
  struct lfds611_slist_element *lfds611_slist_get_next( struct lfds611_slist_element *se, struct lfds611_slist_element **next_se );
  struct lfds611_slist_element *lfds611_slist_get_head_and_then_next( struct lfds611_slist_state *ss, struct lfds611_slist_element **se );





  /***** lfds611_stack *****/

  /***** enums *****/
  enum lfds611_stack_query_type
  {
    LFDS611_STACK_QUERY_ELEMENT_COUNT,
    LFDS611_STACK_QUERY_VALIDATE
  };

  /***** incomplete types *****/
  struct lfds611_stack_state;

  /***** public prototypes *****/
  int lfds611_stack_new( struct lfds611_stack_state **ss, lfds611_atom_t number_elements );
  void lfds611_stack_use( struct lfds611_stack_state *ss );
  void lfds611_stack_delete( struct lfds611_stack_state *ss, void (*user_data_delete_function)(void *user_data, void *user_state), void *user_state );

  void lfds611_stack_clear( struct lfds611_stack_state *ss, void (*user_data_clear_function)(void *user_data, void *user_state), void *user_state );

  int lfds611_stack_push( struct lfds611_stack_state *ss, void *user_data );
  int lfds611_stack_guaranteed_push( struct lfds611_stack_state *ss, void *user_data );
  int lfds611_stack_pop( struct lfds611_stack_state *ss, void **user_data );

  void lfds611_stack_query( struct lfds611_stack_state *ss, enum lfds611_stack_query_type query_type, void *query_input, void *query_output );





  #define __LIBLFDS611_H

#endif

guoxiaoqian8028
关注
专栏目录
Java基本数据类型与封装类型详解(int和Integer区别)
08-31
Java编程语言中有两种类型的变量：基本数据类型和封装类型。基本数据类型是Java语言预定义的，它们直接存储值，而封装类型则是这些基本类型的对象形式。本文将深入探讨Java中的int基本数据类型和Integer封装类型之间...
后台开发技术基础之无锁队列
脚踏实地，不断突破自我，每天有收获就OK
03-02 673
１．kafaka是scala语言开发的,先安装下scala语言 先安装java开发环境,解压压缩包到指定目录,并设置环境变量.然后使环境变量生效.2.
liblfds 测试
weixin_30668887的博客
04-11 176
liblfds 是一个灵活的无锁的数据结构库。支持 x86、x64、ARM 上的 Windows 和 Linux 系统。当前该数据结构库包含：列表、队列、ringbuffer、链接列表和堆栈。 使用 liblfds 6.1.1 在一台32 核心的X86机器上测试了一下，这里贴出一部分，从数据看来，核心越多，每核心每秒操作数 反而越低，总体性能曾下降趋势，怪了，顿时影响我对这个库的信心 Ben...
分享：liblfds 6.1.0 发布，C 数据结构库
01-01 135
分享：liblfds 6.1.0 发布，C 数据结构库 liblfds 6.1.0 发布，C 数据结构库 http://www.oschina.net/news/36299/liblfds-6-1-0 ...
极客时间-左耳听风-程序员攻略-异步I/O模型和Lock-Free编程
weixin_30883311的博客
05-08 477
异步 I/O 模型 异步 I/O 模型其中的设计模式或是解决方法可以借鉴到分布式架构上来。 史蒂文斯（Stevens）在《UNIX 网络编程》一书 6.2 I/O Models 中介绍了五种 I/O 模型。 阻塞 I/O 非阻塞 I/O I/O 的多路复用（select 和 poll） 信号驱动的 I/O（SIGIO） 异步 I/O（POSIX 的 aio_functions） C1...
28.java基本类型封装.docx
09-20
为了能够对基本数据类型进行更加灵活的操作，Java提供了对应的包装类，如`Integer`、`Double`、`Character`等。 #### 二、基本数据类型的包装类概述 Java为每一种基本数据类型都提供了一个对应的包装类，具体如下...
全面了解java基本类型和封装类型的区别及应用
09-01
这些类允许我们将基本类型的数据封装进对象中，从而可以利用对象的方法和特性。例如，Integer类提供了如`valueOf()`和`toString()`等方法，便于进行数值转换和字符串表示。封装类型在内存中是在堆上创建的，这意味着...
Java 八种基本类型和基本类型封装类
08-29
下面将对 Java 八种基本类型和基本类型封装类进行详细的介绍。 一、基本类型的分类 Java 中的基本类型可以分为两类：数值类型和布尔类型。数值类型又可以分为整数类型和浮点数类型。 1. 整数类型：包括 byte、...
Java中int与integer的区别（基本数据类型与引用数据类型）
12-09
Java提供了针对所有基本数据类型的封装类，如 `Byte`, `Short`, `Character`, `Long`, `Float`, `Double`, `Boolean`。这些封装类主要用于支持面向对象的特性，如对象的实例化、方法调用等。当声明一个 `Integer` ...
【原创】无锁编程技术及实现
热门推荐
heiyeluren的blog（黑夜路人的开源世界）
11-04 1万+
无锁编程技术及实现作者：jx （360电商技术组） 1.基于锁的编程的缺点 多线程编程是多CPU系统在中应用最广泛的一种编程方式，在传统的多线程编程中，多线程之间一般用各种锁的机制来保证正确的对共享资源（share resources）进行访问和操作。在多线程编程中只要需要共享某些数据，就应当将对它的访问串行化。比如像++count(count是整型变量)这样的简单操作也得加锁，因为即便是增量操作
liblfds的makefile.windows
一个人，在路上
12-25 943
##### paths ##### BINDIR = bin INCDIR = inc OBJDIR = obj SRCDIR = src ##### misc ##### QUIETLY = 1>nul 2>nul ##### sources, objects and libraries ##### BINNAME = liblfds611 LIB_BINARY = $(BINDIR
一个用 C++ 实现的快速无锁队列
okletsgo007的专栏
06-06 9131
在进程间传递数据很烦人，真心烦人。一步做错，数据就会损坏。（相较于其他读写方式）即使数据排列正确，也更易出错。 一如既往的，有两种方式处理这个问题：简单的方式、麻烦的方式。 简单的方式 使用你使用平台提供的锁（互斥、临界区域，或等效）。这从概念上不难理解，使用上更简单。你无需担心排列问题，库或OS会替你解决。使用锁的唯一问题就是慢（这里的“慢”是相对而言的：一般应用，它的速度足够了）。 T
【原版的】无锁编程与实现
weixin_34190136的博客
09-22 126
无锁编程技术及实现作者：jx （360电商技术组） 1.基于锁的编程的缺点 多线程编程是多CPU系统在中应用最广泛的一种编程方式，在传统的多线程编程中，多线程之间一般用各种锁的机制来保证正确的对共享资源（share resources）进行訪问和操作。在多线程编程中仅仅要须要共享某些数据，就应当将对它的訪问串行化。比方像++count(count是整型变量)这种简单操作也得加锁，由于即便是增量...
《左耳听风》读书心得之高手成长篇书单
qq_37462018的博客
05-23 2090
一直佩服左耳朵耗子叔的知识广度，深度，看了他的专栏对人生规划清楚多了，下面分享下他推荐的高手成长需要读的书 程序员练级攻略：Linux系统、内存和网络 https://access.redhat.com/documentation/en-us/red_hat_enterprise_linux/7/ 红帽企业Linux 7的产品文档 https://github.com/0xAX/linux-ins...
liblfds的readme
一个人，在路上
12-25 856
introduction ============ Welcome to liblfds, a portable, license-free, lock-free data structure library written in C. supported platforms =================== Out-of-the-box ports are provid
Intel® Software Guard Extensions (SGX) SW Development Guidance for Potential Bounds Check Bypass中文
weixin_43184929的博客
08-26 1952
Rust-SGX-SDK 阅读intel指导翻译 Enclave输入 三种Enclave输入模式会导致被攻击的风险： 输入被解释为地址/指针 输入值参与地址计算 输入指向的内容被解释为地址，或参与地址运算 攻击者可以改变输入参数，是其直接或简介计算生成的地址指向所泄漏的secret。此时，由于输入会经过一个输入指针是否在enclave外的判断，于是符合了spectre攻击的条件导致推测执行，从而side channel attack 一个enclave是会包含这类参数的，因为在编译过程中，Edger8
Ubuntu16.04进行交叉编译MYSQL5.7.18的具体步骤
haiyangfan的专栏
07-11 5559
1.首先下载好MYSQL5.7.18的源码包，分别解压到MYSQL5.7.18-pc目录和MYSQL5.7.18-arm目录，这个要分别编译的； 2.进行普通PC的源码编译，进入MYSQL5.7.18-pc目录，运行下面的cmake命令： cmake . -LH -DCMAKE_INSTALL_PREFIX=/usr/local/mysql -DMYSQL_DATADIR=/usr/l
(转)无锁编程：Lock-Free Data Structures
洋葱的专栏
09-23 7593
lock-free 无锁 编程 数据结构 CAS
PC之间的数据通讯封装解封装流程详解
数据通讯封装解封装流程是计算机网络中的一种基本过程，它描述了数据从源设备到目的设备的传输过程。下面我们将详细介绍这个过程。 首先，PC1想要与PC2建立连接，于是PC1的应用层向PC2发出一个Telnet请求。该请求下...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值