Python语言与C语言数据交互的场景还是比较常见的，例如在使用python优秀的数据处理可视化等优势的同时，对于某些优秀的开源C/C++的软件库的调用就需要用到ctypes库函数对动态库进行API的灵活调用了，再例如在某些场景下，C语言的数据需要可视化，而C语言的可视化接口的支持是很薄弱的，这里可以采用Python强大的可视化效果来验证数据的正确性(也可以采用MATLAB完成可视化)。 再比如在某些Demo测试场景下，使用Python便捷部署的神经网络框架在使用获取内存图像数据时也可能使用到Python和C之间数据交换的需求。

一、python与C交互的重要库 ctypes

        ctypes库作为python与C之间的交互的重要库，其定义了各类数据类型与C语言中的数据类型进行对应，其中包括了char，int，POINTER等等，具体可以参看数据手册。ctypes还能够通过CDLL接口应用C语言的动态库.so，在调用接口过程中，应该要严格配置Python端调用动态库函数接口的参数类型(不能有任何偏差)，应该掌握如何定义数组缓冲区并操作地址变量，同时能够使用接口获取变量地址，从而传给C-API使用，基础如下所示：

1. 数组类型定义及使用

测试代码：

1 # 特殊ctypes类型数组类型定义
2 ArrayTestType = ctypes.c_uint8 * 10 # 重定义数据类型
3 ArrayTest = ArrayTestType(11) # 定义数据并初始化数据赋值为11
4 ArrayTest[5] = 20 # 对数据进行赋值处理
5 print('Line', sys._getframe().f_lineno, ':', ArrayTest, type(ArrayTest), ArrayTestType, type(ArrayTestType))
6 print('Line', sys._getframe().f_lineno, ':', ArrayTest[0], ArrayTest[5])

运行结果：

Line 20 : <__main__.c_ubyte_Array_10 object at 0x7fd1318e8ea0> <class '__main__.c_ubyte_Array_10'> <class '__main__.c_ubyte_Array_10'> <class '_ctypes.PyCArrayType'>
Line 21 : 11 20

这里可以看到 ArrayTestType 的类型其实为 PyCArrayType PythonC数组类型，因此 ArrayTestType 可以定义一个 unsigned char Array[10] 的数组。

注：数组类型的缩略定义方法(相当于上述步骤的两步)

# 定义一个大小为10指针实例作为缓存, 等效为 Step1:DataType = c_uint8 * LENGTH --> Step2:DataPoint = DataType()
DataPoint = (c_uint8 * LENGTH)() 

2. 动态库的加载及接口调用

测试代码：

1 # 从C语言或者C++的动态库当中加载C函数以调用
2 p = os.getcwd() + '/libfunc.so' # 获取当前的动态库的绝对路径位置
3 f = cdll.LoadLibrary(p) # 使用LoadLibrary接口加载C语言动态库
4 
5 # Python Class类 到 C struct结构体 数据类型的传输转换
6 Sfunction = f.py_struct_address # 从当前库当中取得clib中的函数py_struct_address，并重命名为Sfunction
7 Sfunction.argtypes = [POINTER(POINT), POINTER(ctypes.c_char)] # 设置当前函数的输入参数

这里使用了 os模块获取了动态库的绝对路径，并调用cdll.LoadLibrary(libpath)，这里使用 argtypes 定义了动态库函数的输入参数类型，分别为结构体指针、char *指针。

3. 定义字符串类型(字符串string)

1 p = create_string_buffer(b"Hello World", 15) # create a 10 byte buffer
2 print('Line', sys._getframe().f_lineno, ':', p,sizeof(p), repr(p.raw))

创建一个string类型的缓冲空间，并返回一个字符串指针指向这串字符串，create_string_buffer 参数分别为字符串、buffer总长度，这个长度不能小于前一个参数字符串的长度大小，否则会报错，p.raw取字符串的内容。

4. Numpy数组的地址获取及应用

测试代码：

 1 # Numpy 数据类型等相互转换测试(将内存数据转换值Python当中)
 2 ImgW = 1669 # 图像宽度
 3 ImgH = 21 # 图像高度
 4 ImgC = 3 # 图像通道数
 5 ImgL = ImgW*ImgH*ImgC # 图像总长度
 6 
 7 ImgArray = np.zeros((ImgW,ImgH,ImgC), dtype=np.ubyte) # 申请图像总空间为多维 zeros 矩阵
 8 print(ImgArray.ctypes.data_as(ctypes.POINTER(ctypes.c_uint8))) # 将numpy数组转换为地址表示方式 data_as 并打印数据类型
 9 ImgArray_addr = ImgArray.ctypes.data_as(ctypes.POINTER(ctypes.c_uint8)) # 获取的指针放置在ImgArray_addr变量当中
10 print('Line', sys._getframe().f_lineno, ':', ImgArray_addr[0],ImgArray_addr[1],ImgArray_addr[2],ImgArray_addr[3])
11 
12 Imgfunction = f.py_img_address # 从当前库当中取得clib中的函数py_struct_address，并重命名为Sfunction
13 Imgfunction.argtypes = [POINTER(ctypes.c_ubyte), ctypes.c_uint32] # 设置当前函数的输入参数规划 usigned char *pointer, unsigned int arg
14 Imgfunction.restype = ctypes.c_int # 设置当前函数返回值参数为 int 类型
15 time_start = time.time()
16 Res = Imgfunction(ImgArray_addr, ImgL) # 调用Imgfunction函数
17 time_end = time.time()
18 print('Line', sys._getframe().f_lineno, ':', 'TimeCost:', (time_end - time_start)*1000, 'ms') # 记录当前函数调用消耗的时间
19 
20 print('Line', sys._getframe().f_lineno, ':\n', ImgArray[:,:,0]) # 打印0通道的数据
21 print('Line', sys._getframe().f_lineno, ':\n', ImgArray[:,:,1]) # 打印1通道的数据
22 print('Line', sys._getframe().f_lineno, ':\n', ImgArray[:,:,2]) # 答应2通道的数据

通过numpy库中数组的成员 ctypes.data_as 方法获取指定类型的指针地址，并将此地址应用在函数库的参数中。

5. 基本类型定义

测试代码：

1 # 使用byref获取ctypes类型数据的地址
2 data = ctypes.c_uint8(10) # 定义一个整数类型的变量，变量初始值为 10，相当于C语言中的 char data=42;
3 data_addr = ctypes.byref(data, 0) # 通过使用byref接口获取地址，相当于C语言中的 char *data_addr = &data; byref(obj, offset) 对应于这段 C 代码:(((char *)&obj) + offset)
4 print('Line', sys._getframe().f_lineno, ':', type(data))
5 print('Line', sys._getframe().f_lineno, ':', type(data_addr))

这里使用 ctypes.c_uint8(10) 定义一个 unsigned char 类型的数据并赋予初值为10，byref函数接口用于获取数据data的地址。

I) 完整的测试代码：

MemoryTest.py

  1 import os
  2 import sys
  3 import time
  4 import ctypes
  5 from ctypes import *
  6 from ctypes import cdll
  7 import numpy as np
  8 
  9 BUFF_SIZE = 6*1024*1024 # 基本的缓冲区域尺寸大小定义
 10 LENGTH = 2*2*3 # 数据长度定义
 11 
 12 # 类定义
 13 class POINT(Structure): # 定义了一个类，类当中的基本成员变量包括了x、y, 相当于C语言中的 struct POINT{int x;inty};
 14     _fields_ = [("x", c_int),("y", c_int),("addr", POINTER(c_uint8)),("len", c_int)]
 15 
 16 # 特殊ctypes类型数组类型定义
 17 ArrayTestType = ctypes.c_uint8 * 10 # 重定义数据类型
 18 ArrayTest = ArrayTestType(11) # 定义数据并初始化数据赋值为11
 19 ArrayTest[5] = 20 # 对数据进行赋值处理
 20 print('Line', sys._getframe().f_lineno, ':', ArrayTest, type(ArrayTest), ArrayTestType, type(ArrayTestType))
 21 print('Line', sys._getframe().f_lineno, ':', ArrayTest[0], ArrayTest[5])
 22 
 23 DataPoint = (c_uint8 * LENGTH)() # 定义一个大小为10指针实例作为缓存, 等效为 Step1:DataType = c_uint8 * LENGTH --> Step2:DataPoint = DataType()
 24 DataPoint[3] = 22
 25 
 26 point = POINT(10, 20, DataPoint,LENGTH) # 定义个类对象Obj, 相当于 struct POINT point={10,20};
 27 print('Line', sys._getframe().f_lineno, ':', point.x, point.y, point.addr[3], point.len)
 28 
 29 point = POINT(y=5) # 定义个类对象Obj, 相当于 struct POINT point={,20};
 30 print('Line', sys._getframe().f_lineno, ':', point.x, point.y)
 31 
 32 # Class类数组定义
 33 addrTest = (POINT * 1)() # 定义一个POINT结构体缓冲地址
 34 addrTest[0].x = 10 # POINT缓冲地址的第一个变量的x成员值
 35 addrTest[0].y = 11 # POINT缓冲地址的第一个变量的y成员值
 36 addrTest[0].addr = DataPoint # POINT缓冲地址的第一个变量的addr成员赋值
 37 addrTest[0].len = LENGTH # POINT缓冲地址的第一个变量的len成员赋值
 38 print('Line', sys._getframe().f_lineno, ':', addrTest, addrTest[0].x,addrTest[0].y,addrTest[0].addr[3],addrTest[0].len)
 39 
 40 TenPointsArrayType = POINT * 3 # 重定义了一个POINT数组类型，相当于C语言中的 #define TenPointsArrayType POINT*3
 41 arr = TenPointsArrayType()
 42 for pt in arr:
 43     print(pt.x, pt.y, pt.addr)
 44 
 45 # 从C语言或者C++的动态库当中加载C函数以调用
 46 p = os.getcwd() + '/libfunc.so' # 获取当前的动态库的绝对路径位置
 47 f = cdll.LoadLibrary(p) # 使用LoadLibrary接口加载C语言动态库
 48 function = f.py_point_address # 从当前库当中取得clib中的函数py_point_address，并重命名为function
 49 function.argtypes = [POINTER(c_byte)] # 设置当前函数的输入参数
 50 
 51 # Python Class类 到 C struct结构体 数据类型的传输转换
 52 Sfunction = f.py_struct_address # 从当前库当中取得clib中的函数py_struct_address，并重命名为Sfunction
 53 Sfunction.argtypes = [POINTER(POINT), POINTER(ctypes.c_char)] # 设置当前函数的输入参数
 54 
 55 p = create_string_buffer(b"Hello World", 15) # create a 10 byte buffer
 56 print('Line', sys._getframe().f_lineno, ':', p,sizeof(p), repr(p.raw))
 57 
 58 time_start = time.time()
 59 Res = Sfunction(addrTest, p)
 60 time_end = time.time()
 61 for i in range(LENGTH):
 62     print(addrTest[0].addr[i])
 63 
 64 print('Line', sys._getframe().f_lineno, ':', addrTest[0].x, addrTest[0].y, addrTest[0].len, addrTest[0].addr)
 65 print('Line', sys._getframe().f_lineno, ':', 'TimeCost:', (time_end - time_start)*1000, 'ms') # 记录当前函数调用消耗的时间
 66 
 67 # Numpy 数据类型等相互转换测试(将内存数据转换值Python当中)
 68 ImgW = 1669 # 图像宽度
 69 ImgH = 21 # 图像高度
 70 ImgC = 3 # 图像通道数
 71 ImgL = ImgW*ImgH*ImgC # 图像总长度
 72 # ImgArray = np.array([[0, 1], [2, 3]], dtype=np.uint8)
 73 ImgArray = np.zeros((ImgW,ImgH,ImgC), dtype=np.ubyte) # 申请图像总空间为多维 zeros 矩阵
 74 # ImgArray = np.array([1,2,3,4], dtype=np.int32)
 75 # print(ImgArray)
 76 # print(ImgArray.ctypes.data)
 77 print(ImgArray.ctypes.data_as(ctypes.POINTER(ctypes.c_uint8))) # 将numpy数组转换为地址表示方式 data_as 并打印数据类型
 78 ImgArray_addr = ImgArray.ctypes.data_as(ctypes.POINTER(ctypes.c_uint8)) # 获取的指针放置在ImgArray_addr变量当中
 79 print('Line', sys._getframe().f_lineno, ':', ImgArray_addr[0],ImgArray_addr[1],ImgArray_addr[2],ImgArray_addr[3])
 80 # print(ImgArray.ctypes.data_as(ctypes.POINTER(ctypes.c_uint8)).contents)
 81 # print(ImgArray.ctypes.data_as(ctypes.POINTER(ctypes.c_uint16)).contents)
 82 # print(ImgArray.ctypes.shape)
 83 # print(ImgArray.ctypes.strides)
 84 
 85 Imgfunction = f.py_img_address # 从当前库当中取得clib中的函数py_struct_address，并重命名为Sfunction
 86 Imgfunction.argtypes = [POINTER(ctypes.c_ubyte), ctypes.c_uint32] # 设置当前函数的输入参数规划 usigned char *pointer, unsigned int arg
 87 Imgfunction.restype = ctypes.c_int # 设置当前函数返回值参数为 int 类型
 88 time_start = time.time()
 89 Res = Imgfunction(ImgArray_addr, ImgL) # 调用Imgfunction函数
 90 time_end = time.time()
 91 print('Line', sys._getframe().f_lineno, ':', 'TimeCost:', (time_end - time_start)*1000, 'ms') # 记录当前函数调用消耗的时间
 92 
 93 print('Line', sys._getframe().f_lineno, ':\n', ImgArray[:,:,0]) # 打印0通道的数据
 94 print('Line', sys._getframe().f_lineno, ':\n', ImgArray[:,:,1]) # 打印1通道的数据
 95 print('Line', sys._getframe().f_lineno, ':\n', ImgArray[:,:,2]) # 答应2通道的数据
 96 
 97 # 一般类型定义以及数据取地址方法 int *pi = &i;
 98 i = ctypes.c_int(42) # 定义一个整数类型的变量，变量初始值为 42，相当于C语言中的 int i=42;
 99 pi = ctypes.pointer(i) # 通过使用pointer接口获取，相当于C语言中的 int *pi = &i;
100 print('Line', sys._getframe().f_lineno, ':', pi.contents) # 查看指针变量的信息
101 print('Line', sys._getframe().f_lineno, ':', pi[0]) # 查看指针所指向的内容，相当于C语言中的 *pi;
102 
103 # ctypes.c_byte 类型的数组定义，等效于 byte a[BUFF_SIZE];
104 a = (c_byte * BUFF_SIZE)() # 定义一个大小为BUFF_SIZE指针实例作为缓存
105 # cast(a, POINTER(c_uint8)) # 函数可以将一个指针实例强制转换为另一种 ctypes 类型
106 print('Line', sys._getframe().f_lineno, ':', a)
107 print('Line', sys._getframe().f_lineno, ':', type(a))
108 time_start = time.time()
109 function(a) # 执行function函数并传入a地址参数
110 time_end = time.time()
111 
112 for i in range(10):
113     print(a[i])
114 
115 print('Line', sys._getframe().f_lineno, ':', 'TimeCost:', (time_end - time_start)*1000, 'ms') # 记录当前函数调用消耗的时间
116 
117 # 使用byref获取ctypes类型数据的地址
118 data = ctypes.c_uint8(10) # 定义一个整数类型的变量，变量初始值为 10，相当于C语言中的 char data=42;
119 data_addr = ctypes.byref(data, 0) # 通过使用byref接口获取地址，相当于C语言中的 char *data_addr = &data; byref(obj, offset) 对应于这段 C 代码:(((char *)&obj) + offset)
120 print('Line', sys._getframe().f_lineno, ':', type(data))
121 print('Line', sys._getframe().f_lineno, ':', type(data_addr))
122 
123 # 使用id获取变量在python的地址
124 value = 'hello world'  # 定义一个字符串变量
125 address = id(value)  # 获取value的地址，赋给address
126 get_value = ctypes.cast(address, ctypes.py_object).value  # 读取地址中的变量
127 print('Line', sys._getframe().f_lineno, ':', address, get_value) # 
128 
129 # 一般Clib函数的调用
130 res = f.func(99) # 普通函数调用
131 print('Line', sys._getframe().f_lineno, ':', res)

function.c

  1 #include <stdio.h>
  2 #include <sys/shm.h>
  3 #include <string.h>
  4 #include <stdlib.h>
  5 #include <time.h>
  6 #include <sys/time.h>
  7 
  8 
  9 #define BUFF_SIZE 6*1024*1024
 10 
 11 typedef struct T_POINT{
 12     int x;
 13     int y;
 14     char * addr;
 15     int len;
 16 }POINT;
 17 
 18 time_t get_timestamp_us(void)
 19 {
 20   time_t timestamp_ms = 0;
 21   struct timeval tv;
 22   
 23   gettimeofday(&tv,NULL);
 24   timestamp_ms = tv.tv_sec * 1000 * 1000 + tv.tv_usec;
 25   return timestamp_ms;
 26 }
 27 
 28 char *file_read(unsigned long *file_bytes, char *file_name)
 29 {
 30   int file_size;
 31   FILE *fd = NULL;
 32   char *file_data = NULL;
 33   fd = fopen(file_name, "rw");
 34   if(fd < 0)
 35   {
 36     printf("File open failed...\n");
 37     return NULL;
 38   }
 39   fseek(fd, 0, SEEK_END);
 40   file_size = ftell (fd);
 41   file_data = malloc(sizeof(char)*file_size);
 42   if(file_data == NULL)
 43   {
 44     printf("Malloc failed...\n");
 45     return NULL;
 46   }
 47   fseek(fd, 0, SEEK_SET);
 48   *file_bytes = fread(file_data,sizeof(char),file_size,fd);
 49   fclose(fd);
 50   return file_data;
 51 }
 52 
 53 /* func.c */
 54 int func(int a)
 55 {
 56     return a*a;
 57 }
 58 
 59 void cycle_calc(int b)
 60 {
 61     int count = 100;
 62     while(count--){
 63         b*=2;
 64         printf("%d - %d\n", count, b);
 65     }
 66 }
 67 
 68 unsigned char * c_point_address(void)
 69 {
 70     unsigned char *Img = malloc(sizeof(unsigned char)*1000);
 71     printf("C-Address:%hhn\n", Img);
 72     memset(Img, 20, 1000);
 73     return Img;
 74 }
 75 
 76 int py_point_address(unsigned char * Addr)
 77 {
 78     unsigned char *Img = malloc(sizeof(unsigned char)*BUFF_SIZE);
 79     // printf("C-Address:%x\n", Img);
 80     // printf("Python-Address:%x\n", Addr);
 81     memset(Img, 20, BUFF_SIZE);
 82     memcpy((unsigned char * )Addr, Img, BUFF_SIZE);
 83     return 1;
 84 }
 85 
 86 int py_struct_address(POINT *pt_POINT, char *str)
 87 {
 88     int i = 0;
 89     for(i=0; i < pt_POINT->len; i++)
 90     {
 91         pt_POINT->addr[i] = i;
 92     }
 93     pt_POINT->x = 16;
 94     pt_POINT->y = 17;
 95     printf("FunctionPrint:%s\n",str);
 96     return 1;
 97 }
 98 
 99 int py_img_address(unsigned char *data, unsigned int lenght)
100 {
101     time_t st,et;
102     unsigned long count=0;
103     unsigned long i=0;
104     st = get_timestamp_us();
105     unsigned char *ImgData = file_read(&i, "./Test.PNG");
106     et = get_timestamp_us();
107     printf("C ### ReadFile time Cost:%ld\n", et - st);
108 
109     printf("Data[%ld]:%d\n", count, *(ImgData+i-1));
110 
111     st = get_timestamp_us();
112     memcpy(data, ImgData, sizeof(unsigned char)*lenght);
113     et = get_timestamp_us();
114     printf("C ### Memcpy time Cost:%ld\n", et - st);
115 
116     printf("py_img_address FunctionPrint:%ld\n", i);
117     return 1;
118 }

exe_shell.sh

1 #!/bin/bash
2 gcc -fPIC -shared function.c -o libfunc.so
3 python3 MemoryTest.py

II) 测试结果如下(测试平台: Ubuntu 18.04.6 LTS + Intel(R) Core(TM) i5-10400F CPU @ 2.90GHz )：

Line 91 : TimeCost: 0.07772445678710938 ms  102KB  Speed=1.25GB/s

二、采用共享内存方式进行IPC通信

内存共享基本方法参考 《进程间通信原理》 ，共享内存的方式需要通过其他通信方式进行进程间数据同步，从而保证共享内存在使用的过程中不被其他进程修改。

main.py

 1 from ctypes import *  
 2 import numpy as np
 3 import codecs
 4 import datetime
 5 
 6 SHM_SIZE = 1024*1024*20 # 20MBytes
 7 SHM_KEY = 123559  
 8 
 9 OUTFILE="Shared.PNG"  
10 try:  
11     rt = CDLL('librt.so')  
12 except:  
13     rt = CDLL('librt.so.1')
14 
15 shmget = rt.shmget
16 shmget.argtypes = [c_int, c_size_t, c_int]  
17 shmget.restype = c_int  
18 shmat = rt.shmat  
19 shmat.argtypes = [c_int, POINTER(c_void_p), c_int]  
20 shmat.restype = c_void_p  
21 
22 shmid = shmget(SHM_KEY, SHM_SIZE, 0o666)
23 
24 if shmid < 0:  
25     print ("System not infected")  
26 else:
27     addr = shmat(shmid, None, 0)  
28     f=open(OUTFILE, 'wb')
29     begin_time = datetime.datetime.now()
30     DataLength = int.from_bytes(string_at(addr,4), byteorder='little', signed=True)   #这里数据文件是小端int16类型
31     ImgData = string_at(addr+4,DataLength)
32     end_time = datetime.datetime.now()
33     print(DataLength, ' Bytes')
34     print('Type:',type(ImgData),' Bytes:', len(ImgData))
35     f.write(ImgData)
36     f.close()  
37 #print ("Dumped %d bytes in %s" % (SHM_SIZE, OUTFILE))
38 print("Success!",end_time-begin_time)

main.c

  1 #include <stdio.h>
  2 #include <stdlib.h>
  3 #include <sys/shm.h>
  4 #include <string.h>
  5 #include <time.h>
  6 #include <sys/time.h>
  7 
  8 #define SHAERD_MEM_SIZE 20 * 1024 * 1024 // 20MBytes
  9 
 10 char mem_free(void *ptr);
 11 time_t get_timestamp_ms(void);
 12 char *file_read(unsigned int *file_bytes, char *file_name);
 13 
 14 int main(int argc, char *argv[])
 15 {
 16     int id = 0;
 17     size_t offset = 0;
 18     char *data = NULL;
 19     char *ImgData = NULL;
 20     unsigned int file_bytes = 0;
 21     time_t start_time, end_time;   
 22     if (argc < 2)
 23     {
 24         printf("args too less\n");
 25         return 0;
 26     }
 27     
 28     id = shmget(123559, SHAERD_MEM_SIZE, IPC_CREAT | 0777);
 29     if (id < 0)
 30     {
 31         printf("get id failed\n");
 32         return 0;
 33     }
 34     
 35     data = shmat(id, NULL, 0);
 36     if (data == NULL)
 37     {
 38         printf("shamt failed\n");
 39         return 0;
 40     }
 41 
 42     ImgData = file_read(&file_bytes, argv[1]);
 43     offset = sizeof(unsigned int);
 44     printf("Size of unsigned long:%d\n", offset);
 45     printf("Size of Image File:%d\n", file_bytes);
 46     start_time = get_timestamp_ms();
 47     memcpy(data, &file_bytes, sizeof(unsigned int));
 48     memcpy(data + offset, ImgData, file_bytes);
 49     end_time = get_timestamp_ms();
 50 
 51     printf("Time Cost:%d\n", end_time - start_time);
 52 
 53     mem_free(ImgData);
 54 
 55     return 0;
 56 }
 57 
 58 char *file_read(unsigned int *file_bytes, char *file_name)
 59 {
 60   int file_size;
 61   FILE *fd = NULL;
 62   char *file_data = NULL;
 63   fd = fopen(file_name, "rw");
 64   if(fd < 0)
 65   {
 66     printf("File open failed...\n");
 67     return NULL;
 68   }
 69   fseek(fd, 0, SEEK_END);
 70   file_size = ftell (fd);
 71   file_data = malloc(sizeof(char)*file_size);
 72   if(file_data == NULL)
 73   {
 74     printf("Malloc failed...\n");
 75     return NULL;
 76   }
 77   fseek(fd, 0, SEEK_SET);
 78   *file_bytes = fread(file_data,sizeof(char),file_size,fd);
 79   fclose(fd);
 80   return file_data;
 81 }
 82 
 83 time_t get_timestamp_ms(void)
 84 {
 85   time_t timestamp_ms = 0;
 86   struct timeval tv;
 87   
 88   gettimeofday(&tv,NULL);
 89   timestamp_ms = tv.tv_sec * 1000 + tv.tv_usec / 1000;
 90   return timestamp_ms;
 91 }
 92 
 93 char mem_free(void *ptr)
 94 {
 95   if(NULL != ptr)
 96   {
 97     free(ptr);
 98     return 0;
 99   }
100   printf("Memory is Empty...\n");
101   return -1;
102 }

编译执行即可

gcc -o main main.c
./main sdlinux.zip # 12MB
python3 main.py

测试结果如下(测试平台：Ubuntu 18.04.6 LTS + Intel(R) Core(TM) i5-10400F CPU @ 2.90GHz )：

Success! 7.091045379638672 ms  12MB  Speed=1.67GB/s

未完待续 ~