OpenXM/doc/ascm2001p/design-outline.tex - diff

Return to design-outline.tex CVS log

Up to [local] / OpenXM / doc / ascm2001p

Diff for /OpenXM/doc/ascm2001p/design-outline.tex between version 1.3 and 1.5

version 1.3, 2001/06/20 02:40:09

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

Line 1

% $OpenXM: OpenXM/doc/ascm2001p/design-outline.tex,v 1.2 2001/06/20 02:09:45 takayama Exp $

% $OpenXM: OpenXM/doc/ascm2001p/design-outline.tex,v 1.4 2001/06/20 03:08:05 takayama Exp $

\section{Design Outline and OpenXM Request for Comments (OpenXM-RFC)}

\section{Design Outline and OpenXM Request For Comments}

As Schefstr\"om\cite{schefstrom}, clarified,

As Schefstr\"om\cite{schefstrom} clarified,

integration of tools and software has three dimensions:

data, control, and user interface.

Data integration concerns with the exchange of data between different

Data integration is concerned with the exchange of data between different

software or same software.

OpenMath \cite{OpenMath} and MP (Multi Protocol) \cite{GKW} are,

for example, general purpose mathematical data protocols.

Line 17 They provide standard ways to express mathematical obj

%\end{verbatim}

%means the (OpenMath) integer $123$ in OpenMath/XML expression.

Control integration concerns with the establishment and management of

Control integration is concerned with the establishment and management of

inter-software communications.

Control involves, for example, a way to ask computations to other processes

Control involves, for example, a way to call subroutines on other processes

and a method to interrupt computations on servers from a client.

RPC, HTTP, MPI, PVM are regarded as a general purpose control protocols or

infrastructures.

MCP (Mathematical Communication Protocol)

MCP (Mathematical Communication Protocol)\cite{iamc}

by Wang \cite{iamc} and OMEI \cite{omei} are such protocols for mathematics.

and OMEI \cite{omei} are such protocols for mathematics.

Although data and control are orthogonal to each other,

real world requires both.

the real world requires both.

NetSolve \cite{netsolve}, OpenMath$+$MCP, MP$+$MCP \cite{iamc},

and MathLink \cite{mathlink} provide both data and control integration.

Each integration method has their own features determined by their

Each integration method has its own features determined by its

own design goals.

OpenXM (Open message eXchange protocol for Mathematics)

is a project aiming to integrate data, control and user interfaces

Line 50 to determine all odd order replicable functions

Takayama has developed

a special purpose system Kan/sm1 \cite{kan},

which is a Gr\"obner engine for the ring of differential operators $D$

and designed as a component of a larger system.

and which was designed as a component of larger systems.

Noro and Takayama firstly tried to integrate these existing two

Noro and Takayama first tried to integrate these existing two

software systems.

We believe that an open integrated system is a future of mathematical

software.

However, we found that it might be just a dream without realizability

and that it is an important research subject to

build a prototype of such an integrated system. % Project X

We started the OpenXM project with the following

fundamental architecture, which is currently described in

OpenXM-RFC 100 proposed standard %% ``draft standard'' and ``standard''

the OpenXM-RFC 100 proposed standard %% ``draft standard'' and ``standard''

\cite{ox-rfc-100}.

\begin{enumerate}

\item Communication is an exchange of messages. The messages are classified into

Line 81 The stack machine is called the

Line 80 The stack machine is called the

Existing mathematical software systems are wrapped with this stack machine.

Minimal requirements for a target software wrapped with the OX stack machine

are as follows:

\begin{enumerate}

(a) The target must have a serialized interface such as a character based

\item The target must have a serialized interface such as a character based

interface.

\item An output of the target must be understandable for computer programs;

(b) An output of the target must be understandable for computer programs;

it should follow a grammar that can be parsed with other software.

\end{enumerate}

\item Any server may have a hybrid interface;

it may accept and execute not only stack machine commands,

but also its original command sequences.

For example,

if we send the following string to the {\tt ox\_asir} server

(OpenXM server of Risa/Asir) \\

(OpenXM server of Risa/Asir)

\verb+ " fctr(x^100-y^100); " + \\

\verb+" fctr(x^100-y^100); "+

and call the stack machine command \\

and call the stack machine command

\verb+ SM_executeStringByLocalParser + \\

\verb+SM_executeStringByLocalParser+

then the server executes the asir command \\

then the server executes the asir command

\verb+ fctr(x^100-y^100); +

(factorize $x^{100}-y^{100}$ over ${\bf Q}$)

and pushes the result onto the stack.

Line 104 and pushes the result onto the stack.

Line 101 and pushes the result onto the stack.

OpenXM package implements the OpenXM-RFC 100 \cite{ox-rfc-100}

and 101 \cite{ox-rfc-101} based on

the above fundamental architecture.

In this paper, we discuss mainly on systems implementing

In this paper, we mainly discuss systems implementing

OpenXM-RFC 100 and 101 on TCP/IP.

For example, the following is a command sequence to ask $1+1$ from

%For example, the following is a command sequence to ask $1+1$ from

the Asir client to the {\tt ox\_sm1} server through TCP/IP:

%the Asir client to the {\tt ox\_sm1} server through TCP/IP:

\begin{verbatim}

%\begin{verbatim}

P = sm1_start();

% P = sm1_start(); ox_push_cmo(P,1); ox_push_cmo(P,1);

ox_push_cmo(P,1); ox_push_cmo(P,1);

% ox_execute_string(P,"add"); ox_pop_cmo(P);

ox_execute_string(P,"add"); ox_pop_cmo(P);

%\end{verbatim}

\end{verbatim}

%Here, {\tt ox\_sm1} is an OpenXM server of Kan/sm1.

Here, {\tt ox\_sm1} is an OpenXM server of Kan/sm1.

Our project of integrating mathematical software

systems is taking the ``RFC'' approach, which has been

used to develop internet protocols.

We think that ``RFC'' approach is an excellent way and

we hope that other groups, who are working on standard protocols,

take this ``RFC'' approach, too.

The OpenXM on MPI \cite{MPI} is currently running on Risa/Asir

as we will see in Section \ref{section:homog}.

We are now preparing the OpenXM-RFC 102 ``Mathematical communication

on MPI'' (draft protocol)

on MPI'' (draft protocol).

based on our experiments on MPI.

In the rest of the paper, we abbreviate

OpenXM-RFC 100 and 101 to OpenXM if no confusion arises.

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