[BACK]Return to design-outline.tex CVS log [TXT][DIR] Up to [local] / OpenXM / doc / issac2000

Diff for /OpenXM/doc/issac2000/design-outline.tex between version 1.1 and 1.9

version 1.1, 1999/12/23 10:25:08 version 1.9, 2000/01/15 12:18:42
Line 1 
Line 1 
 % $OpenXM$  % $OpenXM: OpenXM/doc/issac2000/design-outline.tex,v 1.8 2000/01/15 03:47:58 takayama Exp $
   
   \section{Design Outline}
   
   As Schefstr\"om clarified in \cite{schefstrom},
   integration of tools and softwares has three dimensions:
   data, control, and user interface.
   
   Data integration concerns with the exchange of data between different
   softwares or same softwares.
   OpenMath \cite{OpenMath} and MP (Multi Protocol) \cite{GKW} are,
   for example, general purpose mathematical data protocols.
   They provide standard ways to express mathematical objects.
   For example,
   \begin{verbatim}
    <OMOBJ>  <OMI> 123 </OMI> </OMOBJ>
   \end{verbatim}
   means the (OpenMath) integer $123$ in OpenMath/XML expression.
   
   Control integration concerns with the establishment and management of
   inter-software communications.
   Control involves, for example, a way to ask computations to 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)
   by Wang \cite{iamc} is such a protocol specialized to mathematics.
   
   Although data and control are orthogonal to each other,
   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 due to their
   own design goals.
   OpenXM (Open message eXchange protocol for Mathematics)
   is a project aiming to integrate data, control and user interfaces
   with design goals motivated by the followings.
   \begin{enumerate}
   \item Noro has involved in the development of a general
   purpose computer algebra system Risa/Asir \cite{asir}.
   An interface for interactive distributed computations was introduced
   to Risa/Asir
   %% version 950831 released
   in 1995.
   The model of computation was RPC (remote procedure call)
   and it had its own serialization.
   A robust interruption protocol was provided
   by  two communication channels
   like the File Transfer Protocol (ftp).
   As an application of this protocol,
   a parallel speed-up was achieved for a Gr\"obner basis computation
   to determine all odd order replicable functions
   (Noro and McKay \cite{noro-mckay}).
   However, the protocol was local in Asir and we thought that we should
   design an open protocol.
   \item Takayama has developed
   a special purpose system Kan/sm1 \cite{kan},
   which is a Gr\"obner engine for the ring of differential operators $D$.
   In order to implement algorithms in $D$-modules due to Oaku
   (see, e.g., \cite{sst-book}),
   factorizations and primary ideal decompositions are necessary.
   Kan/sm1 does not have an implementation for these and called
   Risa/Asir as a UNIX external program.
   This approach was not satisfactory.
   Especially, we could not write a clean interface code between these
   two systems.
   We thought that it is necessary to provide a data and control protocol
   for Risa/Asir to work as a server of factorization and primary ideal
   decomposition.
   \item We have been profitted by increasing number
   of mathematical softwares.
   These are usually ``expert'' systems in one area of mathematics
   such as ideals, groups, numbers, polytopes, and so on.
   They have their own interfaces and data formats.
   It is fine for intensive users of these systems.
   However, for users who want to explore a new area of mathematics with these
   softwares or users who need these systems only occasionally,
   a unified system will be more convenient.
   
   \item  We believe that an open integrated system is a future of mathematical
   softwares.
   However, it might be just a dream without realizability.
   We want to build a prototype of such an open system by using
   existing standards, technologies and several mathematical softwares.
   We want to see how far we can go with this approach.
   \end{enumerate}
   
   Motivated with these, we started the OpenXM project with the following
   fundamental architecture.
   \begin{enumerate}
   \item Communication is an exchange of messages. The messages are classified into
   three types:
   DATA, COMMAND, and SPECIAL.
   They are called OX (OpenXM) messages,
   {\it OX data messages} wrap mathematical data.
   We use standards of mathematical data formats such as OpenMath and MP
   as well as our own data format
   ({\it CMO --- Common Mathematical Object format}).
   \item Servers, which provide services to other processes, are stack machines.
   The stack machine is called the
   {\it OX stack machine}.
   Existing mathematical softwares are wrapped with this stack machine.
   Minimal requirements for a target software wrapped with the OX stack machine
   are as follows:
   \begin{enumerate}
   \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;
   it should follow a grammar that can be parsed with other softwares.
   \end{enumerate}
   \item Any server may have a hybrid interface;
   it may accept and execute its original command sequences.
   For example,
   if we send the following string to {\tt ox\_asir} server
   (OpenXM server based on Risa/Asir) \\
   \verb+        " fctr(x^100-y^100); "      + \\
   and call the stanck machine command  \\
   \verb+        SM_executeStringByLocalParser    + \\
   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.
   \end{enumerate}
   OpenXM package  is based on above fundamental architecture.
   For example, the following is a command sequence to ask $1+1$ from
   the Asir client to the {\tt ox\_sm1} server:
   \begin{verbatim}
     P = sm1_start();
     ox_push_cmo(P,1); ox_push_cmo(P,1);
     ox_execute_string(P,"add"); ox_pop_cmo(P);
   \end{verbatim}
   Here, {\tt ox\_sm1} is an OpenXM server based on Kan/sm1.
   
   The current system, OpenXM on TCP/IP,
   uses the client-server model.
   The OpenXM on MPI \cite{MPI} is currently running on Risa/Asir
   as we will see in Section \ref{section:homog}.
   However, we focus only on the system based on TCP/IP in this paper.
   
   
   
   
Legend:
Removed from v.1.1  
changed lines
  Added in v.1.9
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>