[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.7

version 1.1, 1999/12/23 10:25:08 version 1.7, 2000/01/15 03:23:59
Line 1 
Line 1 
 % $OpenXM$  % $OpenXM: OpenXM/doc/issac2000/design-outline.tex,v 1.6 2000/01/15 02:24:18 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 and design motivations.
   OpenXM (Open message eXchange protocol for Mathematics)
   is a project aiming to integrate data, control and user interfaces
   with its own set of design goals.
   To explain our design outline, we start with a list of
   our motivations.
   \begin{enumerate}
   \item Noro has developed a general
   purpose computer algebra system Risa/Asir \cite{asir}.
   An interface for interactive distributed computations was introduced
   in 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 method was provided by having two communication channels
   like ftp.
   As an application of this robust and the interactive distributed computation
   system, speed-up was achieved for a huge Gr\"obner basis computation
   to determine all odd order replicable functions
   by Noro and McKay \cite{noro-mckay}.
   However, the protocol was closed in Asir and we thought that we should
   design an open protocol.
   \item Takayama has developed
   a special purpose computer algebra 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 were necessary.
   Kan/sm1 does not have an implementation for these and called
   Risa/Asir as a C library or 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 The number of mathematical softwares is increasing rapidly in the last
   decade of the 20th century.
   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.
   Interfaces are sometimes specialized to a specific field of mathematics
   or poor.
   It is fine for intensive and serious 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 system 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 others.
   The messages are called OX (OpenXM) messages.
   Mathematical data are wrapped with {\it OX messages}.
   We use standards of mathematical data formats such as OpenMath and MP
   and our own data format ({\it CMO --- Common Mathematical Object format})
   as data expressions.
   \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 ox\_asir server
   {\footnotesize
   \begin{verbatim}
         " fctr(x^10-y^10); "
   \end{verbatim}
   }
   and call the stanck machine command
   SM\_executeStringByLocalParser,
   then the server executes the asir command
   \verb+ fctr(x^10-y^10); +
   (factorize $x^10-y^10$ over ${\bf Q}$)
   and push the result on the stack.
   \end{enumerate}
   We are implementing a package, OpenXM package.
   It is based on above fundamental architecture.
   For example, the following is a command sequence to ask $1+1$ from
   the Asir client to the 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}
   The current system, OpenXM on TCP/IP,
   uses client-server model and the TCP/IP is used for interprocess
   communications.
   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.7
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>