\documentclass[11pt,twoside]{article}\makeatletter

\IfFileExists{xcolor.sty}%
  {\RequirePackage{xcolor}}%
  {\RequirePackage{color}}
\usepackage{colortbl}
\usepackage{wrapfig}
\usepackage{ifxetex}
\ifxetex
  \usepackage{fontspec}
  \usepackage{xunicode}
  \catcode`⃥=\active \def⃥{\textbackslash}
  \catcode`❴=\active \def❴{\{}
  \catcode`❵=\active \def❵{\}}
  \def\textJapanese{\fontspec{Noto Sans CJK JP}}
  \def\textChinese{\fontspec{Noto Sans CJK SC}}
  \def\textKorean{\fontspec{Noto Sans CJK KR}}
  \setmonofont{DejaVu Sans Mono}
  
\else
  \IfFileExists{utf8x.def}%
   {\usepackage[utf8x]{inputenc}
      \PrerenderUnicode{–}
    }%
   {\usepackage[utf8]{inputenc}}
  \usepackage[english]{babel}
  \usepackage[T1]{fontenc}
  \usepackage{float}
  \usepackage[]{ucs}
  \uc@dclc{8421}{default}{\textbackslash }
  \uc@dclc{10100}{default}{\{}
  \uc@dclc{10101}{default}{\}}
  \uc@dclc{8491}{default}{\AA{}}
  \uc@dclc{8239}{default}{\,}
  \uc@dclc{20154}{default}{ }
  \uc@dclc{10148}{default}{>}
  \def\textschwa{\rotatebox{-90}{e}}
  \def\textJapanese{}
  \def\textChinese{}
  \IfFileExists{tipa.sty}{\usepackage{tipa}}{}
\fi
\def\exampleFont{\ttfamily\small}
\DeclareTextSymbol{\textpi}{OML}{25}
\usepackage{relsize}
\RequirePackage{array}
\def\@testpach{\@chclass
 \ifnum \@lastchclass=6 \@ne \@chnum \@ne \else
  \ifnum \@lastchclass=7 5 \else
   \ifnum \@lastchclass=8 \tw@ \else
    \ifnum \@lastchclass=9 \thr@@
   \else \z@
   \ifnum \@lastchclass = 10 \else
   \edef\@nextchar{\expandafter\string\@nextchar}%
   \@chnum
   \if \@nextchar c\z@ \else
    \if \@nextchar l\@ne \else
     \if \@nextchar r\tw@ \else
   \z@ \@chclass
   \if\@nextchar |\@ne \else
    \if \@nextchar !6 \else
     \if \@nextchar @7 \else
      \if \@nextchar (8 \else
       \if \@nextchar )9 \else
  10
  \@chnum
  \if \@nextchar m\thr@@\else
   \if \@nextchar p4 \else
    \if \@nextchar b5 \else
   \z@ \@chclass \z@ \@preamerr \z@ \fi \fi \fi \fi
   \fi \fi  \fi  \fi  \fi  \fi  \fi \fi \fi \fi \fi \fi}
\gdef\arraybackslash{\let\\=\@arraycr}
\def\@textsubscript#1{{\m@th\ensuremath{_{\mbox{\fontsize\sf@size\z@#1}}}}}
\def\Panel#1#2#3#4{\multicolumn{#3}{){\columncolor{#2}}#4}{#1}}
\def\abbr{}
\def\corr{}
\def\expan{}
\def\gap{}
\def\orig{}
\def\reg{}
\def\ref{}
\def\sic{}
\def\persName{}\def\name{}
\def\placeName{}
\def\orgName{}
\def\textcal#1{{\fontspec{Lucida Calligraphy}#1}}
\def\textgothic#1{{\fontspec{Lucida Blackletter}#1}}
\def\textlarge#1{{\large #1}}
\def\textoverbar#1{\ensuremath{\overline{#1}}}
\def\textquoted#1{‘#1’}
\def\textsmall#1{{\small #1}}
\def\textsubscript#1{\@textsubscript{\selectfont#1}}
\def\textxi{\ensuremath{\xi}}
\def\titlem{\itshape}
\newenvironment{biblfree}{}{\ifvmode\par\fi }
\newenvironment{bibl}{}{}
\newenvironment{byline}{\vskip6pt\itshape\fontsize{16pt}{18pt}\selectfont}{\par }
\newenvironment{citbibl}{}{\ifvmode\par\fi }
\newenvironment{docAuthor}{\ifvmode\vskip4pt\fontsize{16pt}{18pt}\selectfont\fi\itshape}{\ifvmode\par\fi }
\newenvironment{docDate}{}{\ifvmode\par\fi }
\newenvironment{docImprint}{\vskip 6pt}{\ifvmode\par\fi }
\newenvironment{docTitle}{\vskip6pt\bfseries\fontsize{22pt}{25pt}\selectfont}{\par }
\newenvironment{msHead}{\vskip 6pt}{\par}
\newenvironment{msItem}{\vskip 6pt}{\par}
\newenvironment{rubric}{}{}
\newenvironment{titlePart}{}{\par }

\newcolumntype{L}[1]{){\raggedright\arraybackslash}p{#1}}
\newcolumntype{C}[1]{){\centering\arraybackslash}p{#1}}
\newcolumntype{R}[1]{){\raggedleft\arraybackslash}p{#1}}
\newcolumntype{P}[1]{){\arraybackslash}p{#1}}
\newcolumntype{B}[1]{){\arraybackslash}b{#1}}
\newcolumntype{M}[1]{){\arraybackslash}m{#1}}
\definecolor{label}{gray}{0.75}
\def\unusedattribute#1{\sout{\textcolor{label}{#1}}}
\DeclareRobustCommand*{\xref}{\hyper@normalise\xref@}
\def\xref@#1#2{\hyper@linkurl{#2}{#1}}
\begingroup
\catcode`\_=\active
\gdef_#1{\ensuremath{\sb{\mathrm{#1}}}}
\endgroup
\mathcode`\_=\string"8000
\catcode`\_=12\relax

\usepackage[a4paper,twoside,lmargin=1in,rmargin=1in,tmargin=1in,bmargin=1in,marginparwidth=0.75in]{geometry}
\usepackage{framed}

\definecolor{shadecolor}{gray}{0.95}
\usepackage{longtable}
\usepackage[normalem]{ulem}
\usepackage{fancyvrb}
\usepackage{fancyhdr}
\usepackage{graphicx}
\usepackage{marginnote}

\renewcommand{\@cite}[1]{#1}


\renewcommand*{\marginfont}{\itshape\footnotesize}

\def\Gin@extensions{.pdf,.png,.jpg,.mps,.tif}

  \pagestyle{fancy}

\usepackage[pdftitle={Overlapped Text Partition Algorithm for Pattern Matching on Hypercube Networked Model},
 pdfauthor={}]{hyperref}
\hyperbaseurl{}

	 \paperwidth210mm
	 \paperheight297mm
              
\def\@pnumwidth{1.55em}
\def\@tocrmarg {2.55em}
\def\@dotsep{4.5}
\setcounter{tocdepth}{3}
\clubpenalty=8000
\emergencystretch 3em
\hbadness=4000
\hyphenpenalty=400
\pretolerance=750
\tolerance=2000
\vbadness=4000
\widowpenalty=10000

\renewcommand\section{\@startsection {section}{1}{\z@}%
     {-1.75ex \@plus -0.5ex \@minus -.2ex}%
     {0.5ex \@plus .2ex}%
     {\reset@font\Large\bfseries}}
\renewcommand\subsection{\@startsection{subsection}{2}{\z@}%
     {-1.75ex\@plus -0.5ex \@minus- .2ex}%
     {0.5ex \@plus .2ex}%
     {\reset@font\Large}}
\renewcommand\subsubsection{\@startsection{subsubsection}{3}{\z@}%
     {-1.5ex\@plus -0.35ex \@minus -.2ex}%
     {0.5ex \@plus .2ex}%
     {\reset@font\large}}
\renewcommand\paragraph{\@startsection{paragraph}{4}{\z@}%
     {-1ex \@plus-0.35ex \@minus -0.2ex}%
     {0.5ex \@plus .2ex}%
     {\reset@font\normalsize}}
\renewcommand\subparagraph{\@startsection{subparagraph}{5}{\parindent}%
     {1.5ex \@plus1ex \@minus .2ex}%
     {-1em}%
     {\reset@font\normalsize\bfseries}}


\def\l@section#1#2{\addpenalty{\@secpenalty} \addvspace{1.0em plus 1pt}
 \@tempdima 1.5em \begingroup
 \parindent \z@ \rightskip \@pnumwidth 
 \parfillskip -\@pnumwidth 
 \bfseries \leavevmode #1\hfil \hbox to\@pnumwidth{\hss #2}\par
 \endgroup}
\def\l@subsection{\@dottedtocline{2}{1.5em}{2.3em}}
\def\l@subsubsection{\@dottedtocline{3}{3.8em}{3.2em}}
\def\l@paragraph{\@dottedtocline{4}{7.0em}{4.1em}}
\def\l@subparagraph{\@dottedtocline{5}{10em}{5em}}
\@ifundefined{c@section}{\newcounter{section}}{}
\@ifundefined{c@chapter}{\newcounter{chapter}}{}
\newif\if@mainmatter 
\@mainmattertrue
\def\chaptername{Chapter}
\def\frontmatter{%
  \pagenumbering{roman}
  \def\thechapter{\@roman\c@chapter}
  \def\theHchapter{\roman{chapter}}
  \def\thesection{\@roman\c@section}
  \def\theHsection{\roman{section}}
  \def\@chapapp{}%
}
\def\mainmatter{%
  \cleardoublepage
  \def\thechapter{\@arabic\c@chapter}
  \setcounter{chapter}{0}
  \setcounter{section}{0}
  \pagenumbering{arabic}
  \setcounter{secnumdepth}{6}
  \def\@chapapp{\chaptername}%
  \def\theHchapter{\arabic{chapter}}
  \def\thesection{\@arabic\c@section}
  \def\theHsection{\arabic{section}}
}
\def\backmatter{%
  \cleardoublepage
  \setcounter{chapter}{0}
  \setcounter{section}{0}
  \setcounter{secnumdepth}{2}
  \def\@chapapp{\appendixname}%
  \def\thechapter{\@Alph\c@chapter}
  \def\theHchapter{\Alph{chapter}}
  \appendix
}
\newenvironment{bibitemlist}[1]{%
   \list{\@biblabel{\@arabic\c@enumiv}}%
       {\settowidth\labelwidth{\@biblabel{#1}}%
        \leftmargin\labelwidth
        \advance\leftmargin\labelsep
        \@openbib@code
        \usecounter{enumiv}%
        \let\p@enumiv\@empty
        \renewcommand\theenumiv{\@arabic\c@enumiv}%
	}%
  \sloppy
  \clubpenalty4000
  \@clubpenalty \clubpenalty
  \widowpenalty4000%
  \sfcode`\.\@m}%
  {\def\@noitemerr
    {\@latex@warning{Empty `bibitemlist' environment}}%
    \endlist}

\def\tableofcontents{\section*{\contentsname}\@starttoc{toc}}
\parskip0pt
\parindent1em
\def\Panel#1#2#3#4{\multicolumn{#3}{){\columncolor{#2}}#4}{#1}}
\newenvironment{reflist}{%
  \begin{raggedright}\begin{list}{}
  {%
   \setlength{\topsep}{0pt}%
   \setlength{\rightmargin}{0.25in}%
   \setlength{\itemsep}{0pt}%
   \setlength{\itemindent}{0pt}%
   \setlength{\parskip}{0pt}%
   \setlength{\parsep}{2pt}%
   \def\makelabel##1{\itshape ##1}}%
  }
  {\end{list}\end{raggedright}}
\newenvironment{sansreflist}{%
  \begin{raggedright}\begin{list}{}
  {%
   \setlength{\topsep}{0pt}%
   \setlength{\rightmargin}{0.25in}%
   \setlength{\itemindent}{0pt}%
   \setlength{\parskip}{0pt}%
   \setlength{\itemsep}{0pt}%
   \setlength{\parsep}{2pt}%
   \def\makelabel##1{\upshape ##1}}%
  }
  {\end{list}\end{raggedright}}
\newenvironment{specHead}[2]%
 {\vspace{20pt}\hrule\vspace{10pt}%
  \phantomsection\label{#1}\markright{#2}%

  \pdfbookmark[2]{#2}{#1}%
  \hspace{-0.75in}{\bfseries\fontsize{16pt}{18pt}\selectfont#2}%
  }{}
      \def\TheFullDate{2013-01-15 (revised: 15 January 2013)}
\def\TheID{\makeatother }
\def\TheDate{2013-01-15}
\title{Overlapped Text Partition Algorithm for Pattern Matching on Hypercube Networked Model}
\author{}\makeatletter 
\makeatletter
\newcommand*{\cleartoleftpage}{%
  \clearpage
    \if@twoside
    \ifodd\c@page
      \hbox{}\newpage
      \if@twocolumn
        \hbox{}\newpage
      \fi
    \fi
  \fi
}
\makeatother
\makeatletter
\thispagestyle{empty}
\markright{\@title}\markboth{\@title}{\@author}
\renewcommand\small{\@setfontsize\small{9pt}{11pt}\abovedisplayskip 8.5\p@ plus3\p@ minus4\p@
\belowdisplayskip \abovedisplayskip
\abovedisplayshortskip \z@ plus2\p@
\belowdisplayshortskip 4\p@ plus2\p@ minus2\p@
\def\@listi{\leftmargin\leftmargini
               \topsep 2\p@ plus1\p@ minus1\p@
               \parsep 2\p@ plus\p@ minus\p@
               \itemsep 1pt}
}
\makeatother
\fvset{frame=single,numberblanklines=false,xleftmargin=5mm,xrightmargin=5mm}
\fancyhf{} 
\setlength{\headheight}{14pt}
\fancyhead[LE]{\bfseries\leftmark} 
\fancyhead[RO]{\bfseries\rightmark} 
\fancyfoot[RO]{}
\fancyfoot[CO]{\thepage}
\fancyfoot[LO]{\TheID}
\fancyfoot[LE]{}
\fancyfoot[CE]{\thepage}
\fancyfoot[RE]{\TheID}
\hypersetup{citebordercolor=0.75 0.75 0.75,linkbordercolor=0.75 0.75 0.75,urlbordercolor=0.75 0.75 0.75,bookmarksnumbered=true}
\fancypagestyle{plain}{\fancyhead{}\renewcommand{\headrulewidth}{0pt}}

\date{}
\usepackage{authblk}

\providecommand{\keywords}[1]
{
\footnotesize
  \textbf{\textit{Index terms---}} #1
}

\usepackage{graphicx,xcolor}
\definecolor{GJBlue}{HTML}{273B81}
\definecolor{GJLightBlue}{HTML}{0A9DD9}
\definecolor{GJMediumGrey}{HTML}{6D6E70}
\definecolor{GJLightGrey}{HTML}{929497} 

\renewenvironment{abstract}{%
   \setlength{\parindent}{0pt}\raggedright
   \textcolor{GJMediumGrey}{\rule{\textwidth}{2pt}}
   \vskip16pt
   \textcolor{GJBlue}{\large\bfseries\abstractname\space}
}{%   
   \vskip8pt
   \textcolor{GJMediumGrey}{\rule{\textwidth}{2pt}}
   \vskip16pt
}

\usepackage[absolute,overlay]{textpos}

\makeatother 
      \usepackage{lineno}
      \linenumbers
      
\begin{document}

             \author[1]{Assoc. Prof.  Ksmvkumar}

             \affil[1]{  Jawaharlal Nehru Technological University}

\renewcommand\Authands{ and }

\date{\small \em Received: 8 December 2012 Accepted: 5 January 2013 Published: 15 January 2013}

\maketitle


\begin{abstract}
        


The web has been continuously growing and getting hourglass shape. The indexed web is measured to contain at least 30 billion pages. It is no surprise that searching data poses serious challenges in terms of quality and speed. Another  important subtask of the pattern discovery  process is sting matching, where in which the pattern occurrence  is already known and we  need  determine  how often  and where it is occurs in  given text. The target of  current  research  challenges and identified the new trends i.e distributed environment where in which the given text file  is divided into subparts  and distributed  to N no. of processors  organized in hypercube networked fashion .To improve  the search speed  and reduce the time complexity we need to run the string matching algorithms in parallel  distributed environment called as hypercube networked model  using RMI method. we considered both KV-KMP and  KV-boyer-moore string matching algorithms for pattern matching  in large text data bases using three data sets and graph's drawn for different patterns.  

\end{abstract}


\keywords{indexed web, pattern, text, distributed, hypercube network, RMI method, and string matching.}

\begin{textblock*}{18cm}(1cm,1cm) % {block width} (coords) 
\textcolor{GJBlue}{\LARGE Global Journals \LaTeX\ JournalKaleidoscope\texttrademark}
\end{textblock*}

\begin{textblock*}{18cm}(1.4cm,1.5cm) % {block width} (coords) 
\textcolor{GJBlue}{\footnotesize \\ Artificial Intelligence formulated this projection for compatibility purposes from the original article published at Global Journals. However, this technology is currently in beta. \emph{Therefore, kindly ignore odd layouts, missed formulae, text, tables, or figures.}}
\end{textblock*}


\let\tabcellsep& 	 	 		 
\section[{Introduction}]{Introduction}\par
tring matching diversely used in many areas of computer sciences. It has been one of the prominent issues of information retrieval system. Some standard algorithms have been used for processing text files against patterns, for example in manipulation of text, text compression, network analysis and also in data retrieval systems. The algorithms studied in the present character forms the basic components in its software implementation and also serve as a model in fields of computer science like system design purposes, web search engines, computer virus signature matching and networking \hyperref[b17]{[1]}. Rapid growth of abundant information makes necessary to have efficient methods for information retrieval.\par
Coping with the growth of the web and query traffic requires scalable information retrieval systems. Today commercial search engines are fully automatic and their web index on a few data centers \hyperref[b18]{[2]}. It is tedious task to come up with scalable indexing and query processing techniques for next generation IRS in the coming future.\par
The web comprises wide variety of content in the form of structured Meta data, databases, maps, images, videos and textual documents etc. \hyperref[b17]{[1]}. The main challenge of present IRS may be scalability. A recent trends envisions that the number of servers required by a search engines to keep up with the load in 2010 may be in the order of millions as such the text size is increasing to tens of billions of pages \hyperref[b17]{[1,}\hyperref[b18]{2]}. Hence it is very urgent to design a truly distributed large scale systems that enables fast and accurate search over very large amount of content \hyperref[b9]{[15]}. In this paper we mainly focus on pattern matching on distributed environment called as hypercube network model using RMI method  {\ref [14]}. Given a pattern may be more common or more specific, we wish to count how many times it occurs in the text and to point out its occurrence positions. For pattern matching we used Kumar Viswanadha-KMP and Kumar Viswanadha-Boyer Moore string matching algorithms for different text files against different pattern files \hyperref[b18]{[2,} {\ref 3]}. Basically Boyer -Moore algorithm is works based on two heuristics: bad character heuristics and good suffix heuristics. The text files is partitioned and processed in two ways, one is non-overlapping and second is overlapping text partitioned processing \hyperref[b18]{[2]}. In both the cases KV-KMP and KV-BM are applied for string matching (pattern matching) and the remote server will be invoked using JAVA RMI method on hypercube networked model to reduce the search time.\par
The paper is organized as follows section II deals with literature survey of string matching in parallel environment, section III deals with text processing techniques called as overlapping and non-overlapping text partitioned in divide and conquer paradigm. Section IV explains about the hypercube model networked systems. Section V presents experimental setup. Result analysis and discussions were discussed in section VI and VII is conclusion. Section VIII gives the references. 
\section[{II.}]{II.} 
\section[{LITERAURE SURVEY}]{LITERAURE SURVEY}\par
Large amounts of data and textual information has been continuously increasing in many fields of information systems. Rapid growth of abundant information makes necessary to have efficient methods for information retrieval \hyperref[b17]{[1]}. This chapter will give an idea how far the algorithms have helped in achieving the desired information along with its time complexities. String matching scan be accomplished by designing algorithms in two categories namely, exact string Year matching algorithms that locates exact match of the pattern in the text string or source string and approximate string matching algorithms that finds closest possible match of pattern in the text with some mismatches. Exact string matching problem can be addressed in two ways software based approach or hardware based approach. Software based algorithms are slow on comparison with hardware based \hyperref[b16]{[22]}. Hardware based solutions to string matching provides efficient data storage and fast matching \hyperref[b7]{[12]}. String matching application in network intrusion detection systems require that the matching shall be accomplished at wire speed , software based solutions could not afford this, due to which hardware based algorithms are chosen mostly over software grounded algorithms. The algorithms discussed below addresses mostly exact string matching. Text represents an important form of data involving a lot of operations \hyperref[b1]{[6]}. Pattern matching is one of the problems encountered in text manipulation. It is about searching and locating substring within a sequence of characters in a raw text. 
\section[{Software Based String Matching Algorithms}]{Software Based String Matching Algorithms}\par
In 1972, Cook exhibited string matching using two way push down auto meta and solved pattern matching in O(m+n) time in worst case where m and n are the lengths of text and pattern respectively \hyperref[b13]{[19]}. However in 1977 Rivest determined that every string matching algorithm must go through at least n-m+1 comparison at worst. This shows there is no solution of obtaining a sub linear n worst time in solving the issue. It means the time needed to run an algorithm must be a function of its input size. The next algorithm discussed makes an attempt to achieve a sub-linear matching time.\par
Donald Knuth-Voughan Pratt-James H. Morrris (1977) basing on modifications of Cook's theorem came up with a new string matching algorithm popularly known as KMP Algorithm, briefly discussed below  {\ref [3]}. It is the first linear pattern matching algorithm discovered with a run time of O(m+n).\par
i. Knuth-Morris-Pratt Algorithm Knuth Morris Pratt's string matching algorithm employs exact string matching technique with linear time complexity  {\ref [3]}. It involves pattern preprocessing .It scans the text string from left to right for pattern matching, while scanning the text it stores the information about the matched characters and whenever a mismatch occurs it uses this information to avoid unnecessary comparisons by sometimes shifting more than one position. It thus avoids backtracking and reduces the number of comparisons unlike naïve approach which wastes the scan information. The present algorithm uses a sliding window which slides over text string and makes shifts as per mismatches. It smartly shifts the pattern over text than the brute-force approach. Window shift uses a KMP formulated prefix function obtained by preprocessing pattern to reduce unnecessary comparisons. The algorithm uses this function to decide about the number of characters to be skipped while shifting the window whenever a mismatch takes place.\par
ii. Aho-Corasick Algorithm Unix fgrep command implementation is based on Aho-Corasick algorithm which locates finite and fixed set of strings in a file and outputs the lines containing at least one of the strings \hyperref[b4]{[8]}. Consider a dictionary (X) containing a fixed set of strings and a text denoted by Y. Let k be the number of strings present in X. Suppose if we wish to find all the occurrences of all the strings of a dictionary. The simple solution would be to repeatedly implement few string matching algorithms on each string .The time complexity of this operation will be O(m+n*k), where m is the sum of the lengths of the k strings of dictionary X and n is the length of the text Y. This indicates the inefficiency of this approach as the text has to be read for k times. This problem is addressed by Aho-Corasick algorithm discussed below, it undergoes sequential read of the text and run time would be O(m+n).The present algorithm extends the weaker versions of Knuth-Morris-Pratt algorithm and also fastly matches a number of patterns at one time against a single text [3].\par
This algorithm locates all the occurrences of finite number of keywords in a string of text. It involves construction of a finite state pattern matching machine, an automaton and then uses the machine for text processing in a single. A keyword is a finite set of strings denoted by K= y 1 , y 2 ,?y n and let X be an arbitrary text string. Pattern matching machine employs three functions namely, goto function g, failure function f, and output function output.\par
iii. Boyer Moore Algorithm B ob Boyer and J. Strother Moore discovered this algorithm in the year 1977 which is known as one of the most efficient algorithms and also stands as a benchmark for string matching process \hyperref[b1]{[6]}. The algorithm compares pattern string within a sliding window over a text string, employing right to left scan of characters inside the window where as the window slides from left to right over the text. The aim of this algorithm is to avoid certain fragments of text that are not eligible for comparison. This decision is taken by placing the window in left alignment with text. The algorithm starts comparing the pattern characters with the text characters in the order of right to left. If 'm' being the length of pattern (x), the algorithm compares x m =y m , where 'y' symbolizes text. On true result of this comparison the procedure continues with x m-1 =y m-1 and on the occurrence of false, the algorithm makes two ways out. One is named as bad character shift or occurrence shift and the other is called as good suffix shift or better factor shift or sometimes matching shift. On grounds of these two measures the window makes shifts and locates the pattern. These measures are explained in the following paragraphs with an example demonstration. 
\section[{Global}]{Global} 
\section[{iv. Horspool Algorithm}]{iv. Horspool Algorithm}\par
Boyer Moore algorithm uses two gauges to know shift distance. Good suffix shift is quite complicate to implement so there was a need of a simplified algorithm using bad character measure \hyperref[b2]{[7]}. This algorithm is a simplification of Boyer -Moore algorithm based on bad character shift. It has been produced by Nigel Horspool in the year 1980.The reason for this simplification is pattern is not always periodic. The concept used is when a bad character, reason for a mismatch is encountered; the shift decision is made by analyzing the characters towards the right of the text window. 
\section[{a. Working Principle}]{a. Working Principle}\par
The process starts by a window on text string of size equal to pattern. The scan of elements goes through right to left inside the window whereas the window slides from left to right over the text.\par
When a mismatch is countered for some wt[i] != wp[j], 0 ? (i, j) < m, wt ? text window character and wp ? pattern window character. Then the match of the right most character of the text window is looked in the pattern so that wt [m-1] = wt  {\ref [i]}, where 0? i < m -1, when both found the characters are therefore aligned causing a window shift.\par
Case I: Suppose the bad character does not exist in the pattern then shift the whole window of size pattern.\par
Case II: There exists two matches of the bad character in the pattern then the rightmost character is preferred. 
\section[{b) Hardware Based String Matching Algorithms i. Mishina Algorithm}]{b) Hardware Based String Matching Algorithms i. Mishina Algorithm}\par
Mishina produced a string matching algorithm for vector processors in the year 1993.This algorithm is used by Hitachi's pipelined vector processor and Integrated vector processor. A vector processor also known as an array processor is a CPU which executes instructions in a single dimensional array of data items \hyperref[b14]{[20]}. Meaning it can perform parallel computations on the elements of array. The current algorithm works in two phases: cutout and check. In the first phase, that is in cutout segment the text string is divided into autonomous serviceable substrings so that each substring can be tested for equality with respective pattern strings in a pipeline using array processors. In the next phase, as the name indicates check phase, a string matching algorithm is employed to perform pattern matching. Here Aho-Corasick algorithm is applied to all substrings drawn from the cutout part. This way of applying string matching is ten times faster than the scalar string matching using Aho-Corasick algorithm.\par
ii. Sidhu's Algorithm for String Matching using Hardware Technology\par
The algorithm is grounded on non-deterministic finite state machine (NFSM) for regular expression matching. In the field of computing, regular expression gives a concise meaning to "match" " " " " \hyperref[b15]{[21]}. The pattern can match one or more text strings. A non-deterministic finite state machine or automaton is a state machine resembles a directed graph that exhibits different states represented by nodes and edges designate character or empty string. The algorithm works by generating regular expressions for every string and NFSM examines the input at a speed of one byte at a time. This approach needs a time of O(m), m symbolize pattern length. NFSMs are tough to implement and requires rebuilding every time a string is added making it complicated. 
\section[{c) String Matching Based on FM-Index}]{c) String Matching Based on FM-Index}\par
Despite of many algorithms presented on string matching, the present attempt to solve string matching problem uses FM-index technique that concatenates the attributes of suffix array and Burrows-Wheeler transformation \hyperref[b16]{[22]}. To understand the working of this architecture the above concepts has to be acknowledged. The next segment of this section presents a detailed discussion of it. 
\section[{i. 2D-LARPBS}]{i. 2D-LARPBS}\par
It represents two-dimensional LARPBS. The model has the system's buses arranged in a twodimensional set up that makes communication among buses more effective  {\ref [23]}. It can be use for the design of both exact and approximate string matching. The construction of these algorithms is based on Hamming distance. 
\section[{ii. Hamming Distance}]{ii. Hamming Distance}\par
Hamming distance measures the amount of inequality between two strings. It can be applied for error detection and correction. For any two strings it gives the number of the corresponding characters that are dissimilar. Using this measure the knowledge of closeness of two strings can be known and thus gives an idea about the operations to be done to obtain one string from another. 
\section[{a. Formal Definition of Hamming Distance}]{a. Formal Definition of Hamming Distance}\par
For strings A and B with same length k, the Hamming distance H (A, B) is given by H (A, B) = no. of positions where A[i]!=B[i] and 0 <i< k. 
\section[{III.}]{III.} 
\section[{Text Processing Techniques}]{Text Processing Techniques}\par
Making text ready to be scanned for string search so that it helps yield reduced search time is text processing. In the previous chapter's literature it was determined that to improve time complexities of string( D D D D D D D D )\par
Year matching approaches parallelization has to be adopted. The root lead towards this starts with divide and conquers procedure and dynamic partition techniques intended for parallel processing, and are presented in the current chapter. a) Divide and Conquer Paradigm i. Introduction\par
Decomposing a complex problem into two or more smaller sub-problems until a simple portion is obtained for easy solvability is dividing and conquer paradigm as the name suggests \hyperref[b18]{[2]}. If the problem is easy it can be solved directly but if a complicated problem persists then breaking into its small instances and solving each instance independently resembles divide and conquer strategy. The solutions to the smaller versions of main problem are clubbed up to attain actual solution to the original instance. It adopts the recursive division while undergoing the breaking up of a problem. The goodness of using divide and conquer strategy lies in the point that it stands as a powerful tool in solving conceptually tough problems \hyperref[b7]{[12]}. The algorithms implementing divide and conquer paradigm are often found to be efficient. It is also considered an apt algorithm to be executed in multiprocessing environment as distinct sub-parts of a problem can be executed in parallel on different machines. The general stages of this strategy would be divide, conquer (solve) and unite. 
\section[{b) Generic Divide and Conquer Algorithm}]{b) Generic Divide and Conquer Algorithm}\par
Input: Problem P and n = Size (P) Output: S = Solution (P) 
\section[{Begin}]{Begin}\par
Step 1: If n is small Solve (P)\par
Step 2: Else divide P into sub-problems p1 and p2 of lengths n1 and n2 respectively such that n1 ? n2 ? n/2\par
Step 3: Conquer S1 ? solve (p1, n1) S2 ? solve (p2, n2)\par
Step 4: Unite solutions to obtain actual solution S ? unite (s1, s2) End IV. 
\section[{Hypercube Network Topology}]{Hypercube Network Topology}\par
A hypercube is a geometrical figure in four or more dimensions similar to a cube in three dimensions with all its edges having equidistant from their respective nodes. For an n-dimensional hypercube, there are 2 n vertices and n*2 n-1 number of edges. In a network, a node is a connection point or a redistribution point, more formally in a physical network it is an electronic device that can send, receive or forward information over the communication channel to other nodes in the network where as edges provides access to the network and also involves in transmitting information in a network over the nodes  {\ref [24]}. A router is an example of an edge device in a network.\par
In computer science, a hypercube network is a configuration of multiple parallel processors having distributed memory such that the locations of the processors are analogous to the vertices of a mathematical hypercube and the links correspond to the edges. For an n-dimensional hypercube, as mentioned above, it has 2 n processing nodes and n*2 n-1 edges coupled in an n-dimensional cube network. The 2 n nodes are designated by binary numbers from 0 to 2 n -1. The nodes are connected by links responsible for intercommunication. The two nodes are connected if the binary numbers assigned to it stand apart by exactly one bit position. 
\section[{a) Message Transmission in Hypercube Network}]{a) Message Transmission in Hypercube Network}\par
Every node in the network has the ability to send, receive and transmit data to other nodes. The information that is passed is in the form of packets. Every node is represented by a unique id that is presented in the binary form. For n-dimensional hypercube, every node is represented in n-bits. b) Algorithm to find the shortest path for transmitting message from source node to target node Input: Source node S n-1 S n-2 ..... S 3 S 2 S 1 S 0 , Target Node T n-1 T n-2 .....T 3 T 2 T 1 T 0 .\par
Output: Path of transmission. 
\section[{Begin}]{Begin}\par
Step 1: Equate each bits of the source node with target node beginning with the right-most bit that is from the LSB of Source node. Formally, compare S 0 with T 0.\par
Step 2: On encountering inequality, if S0!=T0 then complement the respective bit to get the next intermediate node for transmission. The next bit would be S n-1 S n-2 ..... S 3 S 2 S 1 S 0 c . Step 3: Repeat steps 1 and 2 for each of all the bits preceding LSB exclusively till the target node is obtained. End.  
\section[{Global Journal of Computer Science and Technology}]{Global Journal of Computer Science and Technology} 
\section[{Experimental Setup}]{Experimental Setup}\par
Experimental setup required for the above implementation is more processors P(at least four) connected with hypercube model on INTERNET of either similar systems (homogeneous ) or dissimilar systems (heterogeneous). P processors where 0<P<5 and time, by taking K patterns where 0<K<4 as key factor, before conducting test \hyperref[b18]{[2]}. 
\section[{a) Parallel kumar viswanadha and Boyer Moore String Matching Employing Overlapped Text Partitions}]{a) Parallel kumar viswanadha and Boyer Moore String Matching Employing Overlapped Text Partitions}\par
The algorithm implements Boyer Moore string matching algorithm in a parallel environment. The input text string is sliced into 'i' subtexts such that each text partition holds (n/P)+m-1 text string characters with m-1 text characters overlapping in each partition, here P refers to the number of processors in the topology, m and n being the lengths of text and pattern string respectively \hyperref[b7]{[12]} .The number of sub texts obtained after partitioning the text string using the above formula equals the number of processors allotted in the architecture, i.e., i=P, thereby representing the static allocation of the processors. The complete idea behind the working of this procedure can be well understood by the algorithm given below.\par
i. Parallel kumar viswandha Boyer Moore Algorithm 
\section[{Begin}]{Begin}\par
Step 1: Input on the user interface text file of size n, pattern file of size m and number of processors (P) available.\par
Step 2: Undergo text file division into ' i ' number of subtexts, each i contains (n/P)+m-1 text characters using m-1 overlapping text characters. The divided sub text files are stored in a directory.\par
Step 3: Broadcast these sub text files to each processor in the topology.\par
Step 4: Each Processor searches the pattern string in the given Sub text file using the Boyer Moore Algorithm and sends back the result.\par
Step 5: Boyer Moore Algorithm 
\section[{Begin}]{Begin}\par
Step 5.1: A window of size pattern slides over the text Scanning m elements of text string with the pattern string of length m from right to left.\par
Step 5.2: On a mismatch use the longest shift distance of the bad character heuristic and Good suffix heuristic. Window shifts are carried till n-m+1 th position is attained on the text string.\par
Step 5.2.1: The bad Character heuristic states that the mismatching text character termed as bad character of the corresponding pattern character is searched for the rightmost occurrence in the left portion of the pattern window, if found the bad character is aligned with it. If occurs nowhere in the pattern then m characters of the text can be skipped.\par
Step 5.2.2: According to the good suffix heuristic, the suffix appending the bad character is searched in the left portion of the pattern and thus aligned if found else skip m characters of the text string.\par
Step 5.3: On a successful match of all the pattern characters with the text characters in the window, locate the pattern string and continue matching for the next occurrence skipping m characters of the text.\par
Step 5.4: Repeat steps 5.1 to 5.3 till n-m+1 position of the text string. End\par
Step 6: Each processor stores the sub results and sends back to the main program to sum up the obtained results.   
\section[{Result Analysis and Discussions}]{Result Analysis and Discussions}\par
We have considering three files for the implementation discussed in the previous chapter such as f 1 of size 1 Mb, f 2 of size 2 Mb, and f 3 of size 3 Mb from TREC-05psn datasets and TREC-09ps micro biology datasets. The pattern files are p 1 , p 2 , p 3 with respect to those three files \hyperref[b18]{[2,}\hyperref[b6]{10,}\hyperref[b7]{12]}. Here bytes mean number of characters. Time is measured in milli seconds p i,j, represents pattern i in file j. Example : p 1, 1 gives pattern 1 in file 1 (f 1 ), p 1, 2 gives pattern 1 in file 2 (f 2 ). File 1 The pattern files that are searched in the text file f 1 are p 1, 1 of size 3 bytes, p 2, 1 of size 10 bytes, and p 3, 1 of size 15 bytes has to be found using KV-Boyer moore Exact string matching algorithlm and as well as KMP Algorithms. of the processors involved in milliseconds, along with the no. of times the pattern is occurred . Actual test is conducted separately for single processor, two processors, three processors and four processors. Every time, while the test is conducted the program gives elapse time for each processor separately. Therefore the average time is calculated from output result based on the maximum time taken by the individual processor among the processors involved for the particular test. The table shows that for each pattern, as the No. of processors increases the time reduces and accuracy Increases. The graph's shows that the search time taken by single processor is more when compared with multiple processors . It is also observed that as the pattern size increases the search time decreases further. For bigger pattern sizes string matching is more easier for Boyer moore algorithm because of less number of mismatches.  This graph is constructed online by feeding the results from the above table. It is evident that the pattern 1 is of size 3 bytes and text file of size 1MB takes the 4.8 ms time to search the pattern but as the No. of pattern 2 the size is 7bytes and it is also behaves similar to pattern 1 in case of more No. of processors but, for pattern 3 of size 10 bytes search time reduces drastically as the pattern size increases and as well as No. of processor increases .Hence our experimental results give excellent out puts and we also conducted more experiments but , results are not presented due space problem Theoretically discussed. 
\section[{Global Journal of Computer Science and Technology}]{Global Journal of Computer Science and Technology}\par
In this paper we have compared stringmatching on single processor with multi-processors in parallel environment on hypercube network. The total time taken by search pattern is going to reduces as the No. of processors increases in network. This application developed for text documents of size only MB. It may extend to any size i.e GB to TB also and any other format likes image and video files etc. There is lot of scope to develop new trends in this area by evolving modern methods and models for increasing search speed and accuracy. In near future we also produce new results by conducting more no. of experiments using the similar setups.\begin{figure}[htbp]
\noindent\textbf{}\includegraphics[]{image-2.png}
\caption{\label{fig_1}E}\end{figure}
 \begin{figure}[htbp]
\noindent\textbf{1}\includegraphics[]{image-3.png}
\caption{\label{fig_2}VolumeFigure 1 :}\end{figure}
 \begin{figure}[htbp]
\noindent\textbf{2}\includegraphics[]{image-4.png}
\caption{\label{fig_4}Figure 2 :}\end{figure}
 \begin{figure}[htbp]
\noindent\textbf{2}\includegraphics[]{image-5.png}
\caption{\label{fig_5}File 2}\end{figure}
 \begin{figure}[htbp]
\noindent\textbf{}\includegraphics[]{image-6.png}
\caption{\label{fig_6}VolumeE}\end{figure}
  			\footnote{© 2013 Global Journals Inc. (US) Year} 			\footnote{© 2013 Global Journals Inc. (US)} 			\footnote{EOverlapped Text Partition Algorithm for Pattern Matching on Hypercube Networked Model} 			\footnote{© 2013 Global Journals Inc. (US) Year} 			\footnote{© 2013 Global Journals Inc. (US) Year} 		 		\backmatter  			  				\begin{bibitemlist}{1}
\bibitem[Kun et al. (2005)]{b9}\label{b9} 	 		\textit{},  		 			Bi Kun 		,  		 			Gu Nai-Jie 		,  		 			Tu Kun 		,  		 			Liu Xiao 		,  		 			- Hu 		,  		 			Liu Gang 		.  	 	 		\textit{A Practical Distributed String matching Algorithm Architecture and Implementation WASET}  		oct. 2005. 19 p. .  	 
\bibitem[Galil (1995)]{b10}\label{b10} 	 		‘A Constant-Time Optimal Parallel String-Matching Algorithm’.  		 			Zvi Galil 		.  	 	 		\textit{Journal of the ACM}  		July 1995. 42 p. .  	 
\bibitem[Arimura et al.]{b11}\label{b11} 	 		\textit{A Fast Algorithm for Discovering optimal String Parrens in Large Text Databases},  		 			Hiroki Arimura 		,  		 			Atsushi Waraki 		,  		 			Ryoichi Fujino 		,  		 			Stno Arikawa 		.  		 	 
\bibitem[Boyer and Moore ()]{b1}\label{b1} 	 		‘A fast String Searching Algorithm’.  		 			R S Boyer 		,  		 			J S Moore 		.  	 	 		\textit{Communications of the ACM}  		1977. 20  (10)  p. .  	 
\bibitem[Blanco et al. (2010)]{b17}\label{b17} 	 		 			Roi Blanco 		,  		 			B Barla 		,  		 			Cambazoglu 		.  		\textit{th LSDS-IR'10 -ACMSIGIR Form},  				Dec-2010. 8.  	 
\bibitem[Viswanadha Raju et al. ()]{b7}\label{b7} 	 		‘Efficient Parallel String Matching Using Partition Method’.  		 			S Viswanadha Raju 		,  		 			S R Mantena 		,  		 			A Vinayababu 		,  		 			Raju 		.  	 	 		\textit{Proc PDCAT-2006},  				 (PDCAT-2006)  		2006. IEEE Computer Society. p. .  	 
\bibitem[Aho and Corasick ()]{b4}\label{b4} 	 		‘Efficient String Matching: An Aid to Bibliographic Search’.  		 			V Aho 		,  		 			M J Corasick 		.  	 	 		\textit{Communication of the ACM}  		1975. 18  (6)  p. .  	 
\bibitem[Sidhu's and Prasarna (2001)]{b15}\label{b15} 	 		‘Fast regular Expression Matching using FPGA's’.  		 			R Sidhu's 		,  		 			V Prasarna 		.  	 	 		\textit{IEEE symposium on FPCCM},  				 (Rohnert park, CA USA)  		April 2001.  	 
\bibitem[Awsan Abdulrahman Hasan and Rashid]{b2}\label{b2} 	 		\textit{Hash-Boyer Moore-Harspool string},  		 			Nurainiabdul Awsan Abdulrahman Hasan 		,  		 			Rashid 		.  		 	 
\bibitem[Herbert Scheldt's (Osborne) Java 2-Complete Reference]{b8}\label{b8} 	 		\textit{Herbert Scheldt's (Osborne) Java 2-Complete Reference},  		5.  	 	 (th edition-2008) 
\bibitem[Viswanadha Raju and Kumar (2011)]{b18}\label{b18} 	 		‘Implementation of String matching on Multiprocessors using divide and Conquer Technique’.  		 			S Viswanadha Raju 		,  		 			K S M V Kumar 		.  	 	 		\textit{2011 3 rd international Conference on Machine Learning and Computing (ICMLC) WWW},  				Dec 2011. Elsevier.com.  	 
\bibitem[Mishina ()]{b14}\label{b14} 	 		‘Kojima string-matching algorithms for vector processing and its implementation in proceedings of’.  		 			Y Mishina 		,  		 			K 		.  	 	 		\textit{IEEE international conference on computer design (ICCD'93)},  				1993. 1993.  	 
\bibitem[Matching Algorithm for Intrusion Detection Systems INCNCS-2012, IPCSIT vol ()]{b3}\label{b3} 	 		‘Matching Algorithm for Intrusion Detection Systems’.  	 	 		\textit{INCNCS-2012, IPCSIT vol},  				 (Singpore)  		2012. 35.  	 
\bibitem[Matching in Strings SIAM J. of Comput ()]{b0}\label{b0} 	 		‘Matching in Strings’.  	 	 		\textit{SIAM J. of Comput}  		1977. 6 p. .  	 
\bibitem[Viswanadha Raju et al. ()]{b6}\label{b6} 	 		‘Optimal Parallel Algorithm for String Matching on Mesh Network Structure’.  		 			S Viswanadha Raju 		,  		 			A Vinaya 		,  		 			Babu 		.  		 \url{Snort.www.snort.org}  	 	 		\textit{International Journal Applied Mathematical Sciences}  		2006. 3  (2)  p. .  	 
\bibitem[Allen and Wilkinson ()]{b5}\label{b5} 	 		\textit{Parallel Programming: Techniques and Applications using Networked Workstations and Parallel Computers},  		 			B Allen 		,  		 			Wilkinson 		.  		1999. Prentice Hall.  	 
\bibitem[Park and George]{b12}\label{b12} 	 		\textit{Parallel String Matching Algorithms Basedon Dataflow},  		 			Jin Hwan Park 		,  		 			K M George 		.  		Stillwater, USA.  		 			Computer Science Department, Oklahoma State University 		 	 
\bibitem[References Références Referencias processors increases it reduces to 0.5ms]{b19}\label{b19} 	 		\textit{References Références Referencias processors increases it reduces to 0.5ms},  		 	 	 (In case of) 
\bibitem[Frenandez et al. ()]{b16}\label{b16} 	 		\textit{Stringmatching in Hardware using the FM-Index},  		 			Edward Frenandez 		,  		 			W Najjar 		,  		 			S Lonardi 		.  		1998.  	 
\bibitem[Cooks ()]{b13}\label{b13} 	 		\textit{Two-way pushdown automata for string matching" journal of IEEE},  		 			Rivest Cooks 		.  		1977.  	 
\end{bibitemlist}
 			 		 	 
\end{document}
