linux内核中的排序接口--sort函数

linux内核中的sort函数,事实上跟我们所说的qsort函数非常像,我们来看看qsort:

qsort 的函数原型是

void qsort(void*base,size_t num,size_t width,int(__cdecl*compare)(const void*,const void*));

參数: 

1 、待排序数组首地址

2 、数组中待排序元素数量

3 、各元素的占用空间大小

4 、指向函数的指针。用于确定排序的顺序。

当中compare函数应写为:


1

2

3

4

int comp(const void*a,const void*b)

{

return *(int*)a-*(int*)b;

}

事实上qsort是一个典型的高速排序的接口函数。

接下来我们来看看linux内核中的排序接口函数sort:

void sort(void *base, size_t num, size_t size,

int (*cmp_func)(const void *, const void *),

void (*swap_func)(void *, void *, int size)) ;

相同的:

1、待排序的数组首地址

2、数组中待排序元素的数量

3、各元素的占用空间大小

4、指向函数的指针,用于确定排序的顺序。

5、指向函数的指针,用于交换元素的顺序(事实上这可有可无,一般能够设置为NULL(空)值)。

接下来,我们来看看它的实现:

跟qsort函数的源代码事实上大致相似:

void sort(void *base, size_t num, size_t size,
	  int (*cmp_func)(const void *, const void *),
	  void (*swap_func)(void *, void *, int size))
{
	/* pre-scale counters for performance */
	int i = (num/2 - 1) * size, n = num * size, c, r;

	if (!swap_func)
		swap_func = (size == 4 ? u32_swap : generic_swap);

	/* heapify */
	for ( ; i >= 0; i -= size) {
		for (r = i; r * 2 + size < n; r  = c) {
			c = r * 2 + size;
			if (c < n - size &&
					cmp_func(base + c, base + c + size) < 0)
				c += size;
			if (cmp_func(base + r, base + c) >= 0)
				break;
			swap_func(base + r, base + c, size);
		}
	}

	/* sort */
	for (i = n - size; i > 0; i -= size) {
		swap_func(base, base + i, size);
		for (r = 0; r * 2 + size < i; r = c) {
			c = r * 2 + size;
			if (c < i - size &&
					cmp_func(base + c, base + c + size) < 0)
				c += size;
			if (cmp_func(base + r, base + c) >= 0)
				break;
			swap_func(base + r, base + c, size);
		}
	}
}

接下来我们看一个实例程序:

将代码从linux内核中抠出来,然后编敲代码:

#include <stdio.h>
#include <stdlib.h>
typedef int u32 ; 

/*
	fri : sort array
	sec : array num
	thr : array only num size
	function:
	function:
*/
void sort(void *base, size_t num, size_t size,
	  int (*cmp_func)(const void *, const void *),
	  void (*swap_func)(void *, void *, int size)) ;
int cmpint(const void *a, const void *b) ;
static void u32_swap(void *a, void *b, int size) ;
static void generic_swap(void *a, void *b, int size); 

int main(void)
{
	int array[10] = {0};

	int i = 0 ;
	printf("随机产生10个100以内的数:\n");
	for(i = 0 ; i < 10 ; i++)
	{
		array[i] = rand()%100;
		printf("array[%d]=%d\n",i , array[i]);
	}

	sort(array , 10 , sizeof(int) , cmpint , u32_swap) ;
	putchar('\n');
	printf("排序后的数:\n");
	for(i = 0 ; i < 10 ; i++)
	{
		printf("arr[%d]=%d\n",i , array[i]);
	}

	return 0 ;
}

void sort(void *base, size_t num, size_t size,
	  int (*cmp_func)(const void *, const void *),
	  void (*swap_func)(void *, void *, int size))
{
	/* pre-scale counters for performance */
	int i = (num/2 - 1) * size, n = num * size, c, r;

	if (!swap_func)
		swap_func = (size == 4 ?

u32_swap : generic_swap);

	/* heapify */
	for ( ; i >= 0; i -= size) {
		for (r = i; r * 2 + size < n; r  = c) {
			c = r * 2 + size;
			if (c < n - size &&
					cmp_func(base + c, base + c + size) < 0)
				c += size;
			if (cmp_func(base + r, base + c) >= 0)
				break;
			swap_func(base + r, base + c, size);
		}
	}

	/* sort */
	for (i = n - size; i > 0; i -= size) {
		swap_func(base, base + i, size);
		for (r = 0; r * 2 + size < i; r = c) {
			c = r * 2 + size;
			if (c < i - size &&
					cmp_func(base + c, base + c + size) < 0)
				c += size;
			if (cmp_func(base + r, base + c) >= 0)
				break;
			swap_func(base + r, base + c, size);
		}
	}
}

int cmpint(const void *a, const void *b)
{
	return *(int *)a - *(int *)b;
}

static void u32_swap(void *a, void *b, int size)
{
	u32 t = *(u32 *)a;
	*(u32 *)a = *(u32 *)b;
	*(u32 *)b = t;
}

static void generic_swap(void *a, void *b, int size)
{
	char t;

	do {
		t = *(char *)a;
		*(char *)a++ = *(char *)b;
		*(char *)b++ = t;
	} while (--size > 0);
}

执行结果:

随机产生10个100以内的数,通过排序接口sort排序后得到例如以下结果,验证成功!

时间: 2024-10-16 07:02:02

linux内核中的排序接口--sort函数的相关文章

(笔记)Linux内核中内存相关的操作函数

linux内核中内存相关的操作函数 1.kmalloc()/kfree() static __always_inline void *kmalloc(size_t size, gfp_t flags) 内核空间申请指定大小的内存区域,返回内核空间虚拟地址.在函数实现中,如果申请的内存空间较大的话,会从buddy系统申请若干内存页面,如果申请的内存空间大小较小的话,会从slab系统中申请内存空间.有关buddy和slab,请参见<linux内核之内存管理.doc> gfp_t flags 的选项

Linux内核中添加系统调用接口简单示例

1. Linux体系结构 Linux系统的地址空间分为用户空间和内核空间,通过系统调用和硬件中断能够完成从用户空间到内核空间的转移. 2. 系统调用接口 ① 一般情况下,用户进程不能访问内核空间.Linux内核中提供了一组用于实现各种系统功能的子程序,用户可以调用它们访问Linux内核的数据和函数,这些子程序称为系统调用接口(SCI). ② 系统调用和普通函数的区别:系统调用由操作系统内核实现,运行于内核态:普通函数调用由函数库或用户自己提供,运行于用户态. 3. 系统调用分类:主要分3大类 ①

linux内核中的时间接口

时钟中断:是硬件中的定时器以固定的时间产生一次中断. 时钟中断频率:1s中的时钟中断次数: 我们可以通过更改相应的配置,来改变一个系统的时钟中断频率. 先来看看X86平台上的时钟中断频率: 有以上可知,内核通过使用 HZ 宏来表示在内核中的时钟频率为CONFIG_HZ,当然我们就可以通过改变 相应的体系结构中的config文件中CONFIG_HZ的值,来调整内核中的时钟频率值. 如果 CONFIG_HZ=1000的话,内核通过时钟频率所能测出的时间的分辨率为 1ms. linux系统中,通过使用

linux内核中对双向链表的操作函数

在linux内核中用的非常多的一种链表是:双向链表.内核中对所用的进程的管理就是通过双向链表来实现的.所以对链表的操作非常的常用也非常的重要,因此内核通过提供一个通用的方法来帮助我们方便的对双链表实现各种操作. struct list_head {struct list_head *next, *prev;} 0,对双向链表中的某个项进行初始化操作的函数: INIT_LIST_HEAD(struct list_head *entry) INIT_LIST_HEAD()的实现方法: static

【转】linux内核中writesb(), writesw(), writesl() 宏函数

writesb(), writesw(), writesl() 宏函数 功能 : writesb()    I/O 上写入 8 位数据流数据 (1字节) writesw()   I/O  上写入 16 位流数据 (2字节) writesl()    I/O 上写入 32 位流数据 ( 4字节 ) 原型 : 引用 #include <asm/io.h> void   writesb (unsigned short ioaddr , void * addr , unsigned long coun

[原理分析]linux内核中的链表原理实践

摘要: 本文根据linux内核的链表定义,尝试自己来完成相关的接口设计,并且构建测试用例,来体会下链表接口的用法. 正文: 首先来看下linux内核提供的链表接口大致如下: struct head_node{ struct head_node* pre; struct head_node* next; }; 即节点中只有两个指针:一个指向前一个元素,一个指向后一个元素:假设我们现在要使用该接口,跟一个int值联合在一起形成数据节点,那么存在两种可能的方式: case1: typedef stru

linux内核中的线程创建接口

介绍一些内核给我们提供的用于在内核中创建线程的内核接口函数. 其实在linux内核中,无论是进程还是线程,都是用struct task_struct结构体来表示的. 用于创建一个内核线程的函数: struct task_struct * kthread_create( int (*threadfn)(void *data),                                           void *data,                                 

Linux操作系统中的系统调用接口函数

在分析病毒样本时发现有些系统函数是必用,有些超常用,现在都列出来,希望和大家交流 转载请注明出处:http://blog.csdn.net/u010484477     O(∩_∩)O谢谢 进程控制 fork 创建一个新进程 clone 按指定条件创建子进程 execve 运行可执行文件 exit 中止进程 _exit 立即中止当前进程 getdtablesize 进程所能打开的最大文件数 getpgid 获取指定进程组标识号 setpgid 设置指定进程组标志号 getpgrp 获取当前进程组

linux内核中的hook函数详解

在编写linux内核中的网络模块时,用到了钩子函数也就是hook函数.现在来看看linux是如何实现hook函数的.     先介绍一个结构体: struct nf_hook_ops,这个结构体是实现钩子函数必须要用到的结构体,其实际的定义为: 其中的成员信息为: hook  :是一个函数指针,可以将自定义的函数赋值给它,来实现当有数据包到达是调用你自定义的函数.自定义函数的返回值为: owner:是模块的所有者,一般owner = THIS_MODULE ;     pf   :是protoc