[LIB]: Knuth-Morris-Pratt textsearch algorithm

Implements a linear-time string-matching algorithm due to Knuth, Morris, and Pratt [1]. Their algorithm avoids the explicit computation of the transition function DELTA altogether. Its matching time is O(n), for n being length(text), using just an auxiliary function PI[1..m], for m being length(pattern), precomputed from the pattern in time O(m). The array PI allows the transition function DELTA to be computed efficiently "on the fly" as needed. Roughly speaking, for any state "q" = 0,1,...,m and any character "a" in SIGMA, the value PI["q"] contains the information that is independent of "a" and is needed to compute DELTA("q", "a") [2]. Since the array PI has only m entries, whereas DELTA has O(m|SIGMA|) entries, we save a factor of |SIGMA| in the preprocessing time by computing PI rather than DELTA. [1] Cormen, Leiserson, Rivest, Stein Introdcution to Algorithms, 2nd Edition, MIT Press [2] See finite automation theory Signed-off-by: Thomas Graf <tgraf@suug.ch> Signed-off-by: David S. Miller <davem@davemloft.net>

[LIB]: Knuth-Morris-Pratt textsearch algorithm
Implements a linear-time string-matching algorithm due to Knuth, Morris, and Pratt [1]. Their algorithm avoids the explicit computation of the transition function DELTA altogether. Its matching time is O(n), for n being length(text), using just an auxiliary function PI[1..m], for m being length(pattern), precomputed from the pattern in time O(m). The array PI allows the transition function DELTA to be computed efficiently "on the fly" as needed. Roughly speaking, for any state "q" = 0,1,...,m and any character "a" in SIGMA, the value PI["q"] contains the information that is independent of "a" and is needed to compute DELTA("q", "a") [2]. Since the array PI has only m entries, whereas DELTA has O(m|SIGMA|) entries, we save a factor of |SIGMA| in the preprocessing time by computing PI rather than DELTA. [1] Cormen, Leiserson, Rivest, Stein Introdcution to Algorithms, 2nd Edition, MIT Press [2] See finite automation theory Signed-off-by: Thomas Graf <tgraf@suug.ch> Signed-off-by: David S. Miller <davem@davemloft.net>
Thomas Graf · David S. Miller
1 parent 2de4ff7bd6
Showing 3 changed files with 156 additions and 0 deletions Side-by-side Diff
lib/Kconfig
lib/Makefile
lib/ts_kmp.c
@@ -70,5 +70,15 @@
 	  Say Y here if you want to provide a textsearch infrastructure
 	  to other subsystems.
  
+config TEXTSEARCH_KMP
+	depends on TEXTSEARCH
+	tristate "Knuth-Morris-Pratt"
+	help
+	  Say Y here if you want to be able to search text using the
+	  Knuth-Morris-Pratt textsearch algorithm.
+
+	  To compile this code as a module, choose M here: the
+	  module will be called ts_kmp.
+
 endmenu
@@ -37,6 +37,7 @@
 obj-$(CONFIG_REED_SOLOMON) += reed_solomon/
  
 lib-$(CONFIG_TEXTSEARCH) += textsearch.o
+obj-$(CONFIG_TEXTSEARCH_KMP) += ts_kmp.o
  
 hostprogs-y	:= gen_crc32table
 clean-files	:= crc32table.h
+/*
+ * lib/ts_kmp.c		Knuth-Morris-Pratt text search implementation
+ *
+ *		This program is free software; you can redistribute it and/or
+ *		modify it under the terms of the GNU General Public License
+ *		as published by the Free Software Foundation; either version
+ *		2 of the License, or (at your option) any later version.
+ *
+ * Authors:	Thomas Graf <tgraf@suug.ch>
+ *
+ * ==========================================================================
+ * 
+ *   Implements a linear-time string-matching algorithm due to Knuth,
+ *   Morris, and Pratt [1]. Their algorithm avoids the explicit
+ *   computation of the transition function DELTA altogether. Its
+ *   matching time is O(n), for n being length(text), using just an
+ *   auxiliary function PI[1..m], for m being length(pattern),
+ *   precomputed from the pattern in time O(m). The array PI allows
+ *   the transition function DELTA to be computed efficiently
+ *   "on the fly" as needed. Roughly speaking, for any state
+ *   "q" = 0,1,...,m and any character "a" in SIGMA, the value
+ *   PI["q"] contains the information that is independent of "a" and
+ *   is needed to compute DELTA("q", "a") [2]. Since the array PI
+ *   has only m entries, whereas DELTA has O(m|SIGMA|) entries, we
+ *   save a factor of |SIGMA| in the preprocessing time by computing
+ *   PI rather than DELTA.
+ *
+ *   [1] Cormen, Leiserson, Rivest, Stein
+ *       Introdcution to Algorithms, 2nd Edition, MIT Press
+ *   [2] See finite automation theory
+ */
+
+#include <linux/config.h>
+#include <linux/module.h>
+#include <linux/types.h>
+#include <linux/string.h>
+#include <linux/textsearch.h>
+
+struct ts_kmp
+{
+	u8 *		pattern;
+	unsigned int	pattern_len;
+	unsigned int 	prefix_tbl[0];
+};
+
+static unsigned int kmp_find(struct ts_config *conf, struct ts_state *state)
+{
+	struct ts_kmp *kmp = ts_config_priv(conf);
+	unsigned int i, q = 0, text_len, consumed = state->offset;
+	const u8 *text;
+
+	for (;;) {
+		text_len = conf->get_next_block(consumed, &text, conf, state);
+
+		if (unlikely(text_len == 0))
+			break;
+
+		for (i = 0; i < text_len; i++) {
+			while (q > 0 && kmp->pattern[q] != text[i])
+				q = kmp->prefix_tbl[q - 1];
+			if (kmp->pattern[q] == text[i])
+				q++;
+			if (unlikely(q == kmp->pattern_len)) {
+				state->offset = consumed + i + 1;
+				return state->offset - kmp->pattern_len;
+			}
+		}
+
+		consumed += text_len;
+	}
+
+	return UINT_MAX;
+}
+
+static inline void compute_prefix_tbl(const u8 *pattern, unsigned int len,
+				      unsigned int *prefix_tbl)
+{
+	unsigned int k, q;
+
+	for (k = 0, q = 1; q < len; q++) {
+		while (k > 0 && pattern[k] != pattern[q])
+			k = prefix_tbl[k-1];
+		if (pattern[k] == pattern[q])
+			k++;
+		prefix_tbl[q] = k;
+	}
+}
+
+static struct ts_config *kmp_init(const void *pattern, unsigned int len,
+				  int gfp_mask)
+{
+	struct ts_config *conf;
+	struct ts_kmp *kmp;
+	unsigned int prefix_tbl_len = len * sizeof(unsigned int);
+	size_t priv_size = sizeof(*kmp) + len + prefix_tbl_len;
+
+	conf = alloc_ts_config(priv_size, gfp_mask);
+	if (IS_ERR(conf))
+		return conf;
+
+	kmp = ts_config_priv(conf);
+	kmp->pattern_len = len;
+	compute_prefix_tbl(pattern, len, kmp->prefix_tbl);
+	kmp->pattern = (u8 *) kmp->prefix_tbl + prefix_tbl_len;
+	memcpy(kmp->pattern, pattern, len);
+
+	return conf;
+}
+
+static void *kmp_get_pattern(struct ts_config *conf)
+{
+	struct ts_kmp *kmp = ts_config_priv(conf);
+	return kmp->pattern;
+}
+
+static unsigned int kmp_get_pattern_len(struct ts_config *conf)
+{
+	struct ts_kmp *kmp = ts_config_priv(conf);
+	return kmp->pattern_len;
+}
+
+static struct ts_ops kmp_ops = {
+	.name		  = "kmp",
+	.find		  = kmp_find,
+	.init		  = kmp_init,
+	.get_pattern	  = kmp_get_pattern,
+	.get_pattern_len  = kmp_get_pattern_len,
+	.owner		  = THIS_MODULE,
+	.list		  = LIST_HEAD_INIT(kmp_ops.list)
+};
+
+static int __init init_kmp(void)
+{
+	return textsearch_register(&kmp_ops);
+}
+
+static void __exit exit_kmp(void)
+{
+	textsearch_unregister(&kmp_ops);
+}
+
+MODULE_LICENSE("GPL");
+
+module_init(init_kmp);
+module_exit(exit_kmp);
...	...	@@ -70,5 +70,15 @@
70	70	Say Y here if you want to provide a textsearch infrastructure
71	71	to other subsystems.
72	72
	73	+config TEXTSEARCH_KMP
	74	+ depends on TEXTSEARCH
	75	+ tristate "Knuth-Morris-Pratt"
	76	+ help
	77	+ Say Y here if you want to be able to search text using the
	78	+ Knuth-Morris-Pratt textsearch algorithm.
	79	+
	80	+ To compile this code as a module, choose M here: the
	81	+ module will be called ts_kmp.
	82	+
73	83	endmenu
...	...	@@ -37,6 +37,7 @@
37	37	obj-$(CONFIG_REED_SOLOMON) += reed_solomon/
38	38
39	39	lib-$(CONFIG_TEXTSEARCH) += textsearch.o
	40	+obj-$(CONFIG_TEXTSEARCH_KMP) += ts_kmp.o
40	41
41	42	hostprogs-y := gen_crc32table
42	43	clean-files := crc32table.h
	1	+/*
	2	+ * lib/ts_kmp.c Knuth-Morris-Pratt text search implementation
	3	+ *
	4	+ * This program is free software; you can redistribute it and/or
	5	+ * modify it under the terms of the GNU General Public License
	6	+ * as published by the Free Software Foundation; either version
	7	+ * 2 of the License, or (at your option) any later version.
	8	+ *
	9	+ * Authors: Thomas Graf <tgraf@suug.ch>
	10	+ *
	11	+ * ==========================================================================
	12	+ *
	13	+ * Implements a linear-time string-matching algorithm due to Knuth,
	14	+ * Morris, and Pratt [1]. Their algorithm avoids the explicit
	15	+ * computation of the transition function DELTA altogether. Its
	16	+ * matching time is O(n), for n being length(text), using just an
	17	+ * auxiliary function PI[1..m], for m being length(pattern),
	18	+ * precomputed from the pattern in time O(m). The array PI allows
	19	+ * the transition function DELTA to be computed efficiently
	20	+ * "on the fly" as needed. Roughly speaking, for any state
	21	+ * "q" = 0,1,...,m and any character "a" in SIGMA, the value
	22	+ * PI["q"] contains the information that is independent of "a" and
	23	+ * is needed to compute DELTA("q", "a") [2]. Since the array PI
	24	+ * has only m entries, whereas DELTA has O(m\|SIGMA\|) entries, we
	25	+ * save a factor of \|SIGMA\| in the preprocessing time by computing
	26	+ * PI rather than DELTA.
	27	+ *
	28	+ * [1] Cormen, Leiserson, Rivest, Stein
	29	+ * Introdcution to Algorithms, 2nd Edition, MIT Press
	30	+ * [2] See finite automation theory
	31	+ */
	32	+
	33	+#include <linux/config.h>
	34	+#include <linux/module.h>
	35	+#include <linux/types.h>
	36	+#include <linux/string.h>
	37	+#include <linux/textsearch.h>
	38	+
	39	+struct ts_kmp
	40	+{
	41	+ u8 * pattern;
	42	+ unsigned int pattern_len;
	43	+ unsigned int prefix_tbl[0];
	44	+};
	45	+
	46	+static unsigned int kmp_find(struct ts_config conf, struct ts_state state)
	47	+{
	48	+ struct ts_kmp *kmp = ts_config_priv(conf);
	49	+ unsigned int i, q = 0, text_len, consumed = state->offset;
	50	+ const u8 *text;
	51	+
	52	+ for (;;) {
	53	+ text_len = conf->get_next_block(consumed, &text, conf, state);
	54	+
	55	+ if (unlikely(text_len == 0))
	56	+ break;
	57	+
	58	+ for (i = 0; i < text_len; i++) {
	59	+ while (q > 0 && kmp->pattern[q] != text[i])
	60	+ q = kmp->prefix_tbl[q - 1];
	61	+ if (kmp->pattern[q] == text[i])
	62	+ q++;
	63	+ if (unlikely(q == kmp->pattern_len)) {
	64	+ state->offset = consumed + i + 1;
	65	+ return state->offset - kmp->pattern_len;
	66	+ }
	67	+ }
	68	+
	69	+ consumed += text_len;
	70	+ }
	71	+
	72	+ return UINT_MAX;
	73	+}
	74	+
	75	+static inline void compute_prefix_tbl(const u8 *pattern, unsigned int len,
	76	+ unsigned int *prefix_tbl)
	77	+{
	78	+ unsigned int k, q;
	79	+
	80	+ for (k = 0, q = 1; q < len; q++) {
	81	+ while (k > 0 && pattern[k] != pattern[q])
	82	+ k = prefix_tbl[k-1];
	83	+ if (pattern[k] == pattern[q])
	84	+ k++;
	85	+ prefix_tbl[q] = k;
	86	+ }
	87	+}
	88	+
	89	+static struct ts_config kmp_init(const void pattern, unsigned int len,
	90	+ int gfp_mask)
	91	+{
	92	+ struct ts_config *conf;
	93	+ struct ts_kmp *kmp;
	94	+ unsigned int prefix_tbl_len = len * sizeof(unsigned int);
	95	+ size_t priv_size = sizeof(*kmp) + len + prefix_tbl_len;
	96	+
	97	+ conf = alloc_ts_config(priv_size, gfp_mask);
	98	+ if (IS_ERR(conf))
	99	+ return conf;
	100	+
	101	+ kmp = ts_config_priv(conf);
	102	+ kmp->pattern_len = len;
	103	+ compute_prefix_tbl(pattern, len, kmp->prefix_tbl);
	104	+ kmp->pattern = (u8 *) kmp->prefix_tbl + prefix_tbl_len;
	105	+ memcpy(kmp->pattern, pattern, len);
	106	+
	107	+ return conf;
	108	+}
	109	+
	110	+static void kmp_get_pattern(struct ts_config conf)
	111	+{
	112	+ struct ts_kmp *kmp = ts_config_priv(conf);
	113	+ return kmp->pattern;
	114	+}
	115	+
	116	+static unsigned int kmp_get_pattern_len(struct ts_config *conf)
	117	+{
	118	+ struct ts_kmp *kmp = ts_config_priv(conf);
	119	+ return kmp->pattern_len;
	120	+}
	121	+
	122	+static struct ts_ops kmp_ops = {
	123	+ .name = "kmp",
	124	+ .find = kmp_find,
	125	+ .init = kmp_init,
	126	+ .get_pattern = kmp_get_pattern,
	127	+ .get_pattern_len = kmp_get_pattern_len,
	128	+ .owner = THIS_MODULE,
	129	+ .list = LIST_HEAD_INIT(kmp_ops.list)
	130	+};
	131	+
	132	+static int __init init_kmp(void)
	133	+{
	134	+ return textsearch_register(&kmp_ops);
	135	+}
	136	+
	137	+static void __exit exit_kmp(void)
	138	+{
	139	+ textsearch_unregister(&kmp_ops);
	140	+}
	141	+
	142	+MODULE_LICENSE("GPL");
	143	+
	144	+module_init(init_kmp);
	145	+module_exit(exit_kmp);