<aside> 💡 Linked List

</aside>

linked_list.c

#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/list.h>
#include <linux/slab.h>  // for kmalloc
#include <linux/time.h>  // 

#define NUM 100000
#define BILLION 1000000000

unsigned long long insert_time = 0;
unsigned long long search_time = 0;
unsigned long long delete_time = 0;

struct my_node {
	struct list_head entry;
	int data;
};

unsigned long long calculate(struct timespec64 *tick, struct timespec64 *tock)
{
	unsigned long long total_time = 0, time_delay = 0; 
	long temp;
	long temp_n;

	if(tock->tv_nsec >= tick->tv_nsec) {

		temp = tock->tv_sec - tick->tv_sec;
		temp_n = tock->tv_nsec - tick->tv_nsec;
	}
	else {
		temp = tock->tv_sec - tick->tv_sec -1;
		temp_n = BILLION + tock->tv_nsec - tick->tv_nsec;

	}

	time_delay = BILLION * temp + temp_n;
	__sync_fetch_and_add(&total_time, time_delay);

	return total_time;

}

void struct_example(void) {
	struct list_head my_list;
	int i;

	struct timespec64 tick, tock;

	// search node
	struct my_node *current_node = NULL;

	// delete node
	struct my_node *tmp_node;

	/* initialize list */
	INIT_LIST_HEAD(&my_list);

	// insert
	/* list element add */
	printk("Linked List Insert");
	ktime_get_ts64(&tick); 

	for (i=0; i<NUM; i++) {
		struct my_node *new = kmalloc(sizeof(struct my_node), GFP_KERNEL);
		new->data = i;
		list_add(&new->entry, &my_list);
	}

	ktime_get_ts64(&tock); 
	insert_time = calculate(&tick, &tock);

	// search 
	printk("Linked List Search");
	ktime_get_ts64(&tick); 

	/* check list */
	list_for_each_entry(current_node, &my_list, entry) {
		printk("current value: %d\\n", current_node->data);
	}

	ktime_get_ts64(&tock); 
	search_time = calculate(&tick, &tock);

	// delete
	/* list element delete */
	printk("Linked List Insert");
	ktime_get_ts64(&tick); 

	list_for_each_entry_safe(current_node, tmp_node, &my_list, entry) {
		printk("current node value: %d\\n", current_node->data);
		list_del(&current_node->entry);
		kfree(current_node);
	}

	ktime_get_ts64(&tock); 
	delete_time = calculate(&tick, &tock);

	/* check list 
	list_for_each_entry(current_node, &my_list, entry) {
		printk("current value: %d\\n", current_node->data);
	}
	*/
}

int __init hello_module_init(void) {
	struct_example();
	printk("module init\\n");
	return 0;

}

void __exit hello_module_cleanup(void) {
	printk("insert time: %llu ns\\n", insert_time);
	printk("search time: %llu ns\\n", search_time);
	printk("delete time: %llu ns\\n", delete_time);

	printk("Bye Module\\n");

}

module_init(hello_module_init);
module_exit(hello_module_cleanup);
MODULE_LICENSE("GPL");

timespec64

<aside> 🚫 기존의 timespec 이 2038년에 overflow 난다는 정보 확인