OpenXM/doc/ascm2001p/homogeneous-network.tex - diff

Return to homogeneous-network.tex CVS log

Up to [local] / OpenXM / doc / ascm2001p

Diff for /OpenXM/doc/ascm2001p/homogeneous-network.tex between version 1.3 and 1.7

version 1.3, 2001/06/20 02:39:25

version 1.7, 2001/06/20 05:42:47

Line 1

% $OpenXM: OpenXM/doc/ascm2001p/homogeneous-network.tex,v 1.2 2001/06/20 01:43:12 noro Exp $

% $OpenXM: OpenXM/doc/ascm2001p/homogeneous-network.tex,v 1.6 2001/06/20 03:18:21 noro Exp $

\subsection{Distributed computation with homogeneous servers}

\label{section:homog}

One of the aims of OpenXM is a parallel speedup by a distributed computation

with homogeneous servers. As the current specification of OpenXM does

with homogeneous servers. Let us see some examples.

not include communication between servers, one cannot expect

%As the current specification of OpenXM does

the maximal parallel speedup. However it is possible to execute

%not include communication between servers, one cannot expect

several types of distributed computation as follows.

%the maximal parallel speedup. However it is possible to execute

%several types of distributed computation as follows.

\subsubsection{Competitive distributed computation by various strategies}

SINGULAR \cite{Singular} implements {\it MP} interface for distributed

computation and a competitive Gr\"obner basis computation is

illustrated as an example of distributed computation.

illustrated as an example of distributed computation by the MP interface.

Such a distributed computation is also possible on OpenXM as follows:

Such a distributed computation is also possible on OpenXM.

The client creates two servers and it requests

Gr\"obner basis comutations by the Buchberger algorithm the $F_4$ algorithm

to the servers for the same input.

The client watches the streams by {\tt ox\_select()}

and the result which is returned first is taken. Then the remaining

server is reset.

\begin{verbatim}

extern Proc1,Proc2$

extern Proc1,Proc2$ Proc1 = -1$ Proc2 = -1$

Proc1 = -1$ Proc2 = -1$

/* G:set of polys; V:list of variables */

/* Mod: the Ground field GF(Mod); O:type of order */

def dgr(G,V,Mod,O)

Line 49 def dgr(G,V,Mod,O)

Line 42 def dgr(G,V,Mod,O)

return [Win,R];

}

\end{verbatim}

In the above Asir program, the client creates two servers and it requests

Gr\"obner basis computations by the Buchberger algorithm

and the $F_4$ algorithm to the servers for the same input.

The client watches the streams by {\tt ox\_select()}

and the result which is returned first is taken. Then the remaining

server is reset.

%\subsubsection{Nesting of client-server communication}

\subsubsection{Nesting of client-server communication}

%Under OpenXM-RFC 100 an OpenXM server can be a client of other servers.

%%Prog: load ("dfff"); df_demo(); enter 100.

%Figure \ref{tree} illustrates a tree-like structure of an OpenXM

Under OpenXM-RFC 100 an OpenXM server can be a client of other servers.

%client-server communication.

Figure \ref{tree} illustrates a tree-like structure of an OpenXM

%\begin{figure}

client-server communication.

%\label{tree}

\begin{figure}

%\begin{center}

\label{tree}

%\begin{picture}(200,70)(0,0)

\begin{center}

%\put(70,70){\framebox(40,15){client}}

\begin{picture}(200,70)(0,0)

%\put(20,30){\framebox(40,15){server}}

\put(70,70){\framebox(40,15){client}}

%\put(70,30){\framebox(40,15){server}}

\put(20,30){\framebox(40,15){server}}

%\put(120,30){\framebox(40,15){server}}

\put(70,30){\framebox(40,15){server}}

%\put(0,0){\framebox(40,15){server}}

\put(120,30){\framebox(40,15){server}}

%\put(50,0){\framebox(40,15){server}}

\put(0,0){\framebox(40,15){server}}

%\put(150,0){\framebox(40,15){server}}

\put(50,0){\framebox(40,15){server}}

\put(150,0){\framebox(40,15){server}}

%\put(90,70){\vector(-2,-1){43}}

%\put(90,70){\vector(0,-1){21}}

\put(90,70){\vector(-2,-1){43}}

%\put(90,70){\vector(2,-1){43}}

\put(90,70){\vector(0,-1){21}}

%\put(40,30){\vector(-2,-1){22}}

\put(90,70){\vector(2,-1){43}}

%\put(40,30){\vector(2,-1){22}}

\put(40,30){\vector(-2,-1){22}}

%\put(140,30){\vector(2,-1){22}}

\put(40,30){\vector(2,-1){22}}

%\end{picture}

\put(140,30){\vector(2,-1){22}}

%\caption{Tree-like structure of client-server communication}

\end{picture}

%\end{center}

\caption{Tree-like structure of client-server communication}

%\end{figure}

\end{center}

%Such a computational model is useful for parallel implementation of

\end{figure}

%algorithms whose task can be divided into subtasks recursively.

Such a computational model is useful for parallel implementation of

algorithms whose task can be divided into subtasks recursively.

%A typical example is {\it quicksort}, where an array to be sorted is

%partitioned into two sub-arrays and the algorithm is applied to each

%sub-array. In each level of recursion, two subtasks are generated

Line 132 def dgr(G,V,Mod,O)

%\end{verbatim}

%A typical example is a parallelization of the Cantor-Zassenhaus

A typical example is a parallelization of the Cantor-Zassenhaus

%algorithm for polynomial factorization over finite fields.

algorithm for polynomial factorization over finite fields,

%which is a recursive algorithm.

which is a recursive algorithm.

%At each level of the recursion, a given polynomial can be

At each level of the recursion, a given polynomial can be

%divided into two non-trivial factors with some probability by using

divided into two non-trivial factors with some probability by using

%a randomly generated polynomial as a {\it separator}.

a randomly generated polynomial as a {\it separator}.

%We can apply the following simple parallelization:

We can apply the following simple parallelization:

%When two non-trivial factors are generated on a server,

When two non-trivial factors are generated on a server,

%one is sent to another server and the other factor is factorized on the server

one is sent to another server and the other factor is factorized on the server

%itself.

itself.

%\begin{verbatim}

%/* factorization of F */

%/* E = degree of irreducible factors in F */

Line 151 def dgr(G,V,Mod,O)

% if ( N == E ) return [F];

% M = field_order_ff(); K = idiv(N,E); L = [F];

% while ( 1 ) {

% /* gererate a random polynomial */

% /* generate a random polynomial */

% W = monic_randpoly_ff(2*E,V);

% /* compute a power of the random polynomial */

% T = generic_pwrmod_ff(W,F,idiv(M^E-1,2));

Line 250 work well on OpenXM.

%Such a distributed computation is also possible on OpenXM as follows:

%The client creates two servers and it requests

%Gr\"obner basis comutations from the homogenized input and the input itself

%Gr\"obner basis computations from the homogenized input and the input itself

%to the servers.

%The client watches the streams by {\tt ox\_select()}

%and the result which is returned first is taken. Then the remaining

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>