OpenXM/doc/issac2000/openxm-stackmachines.tex - diff

Return to openxm-stackmachines.tex CVS log

Up to [local] / OpenXM / doc / issac2000

Diff for /OpenXM/doc/issac2000/openxm-stackmachines.tex between version 1.8 and 1.12

version 1.8, 2000/01/15 03:46:27

version 1.12, 2000/01/17 01:23:41

Line 1

% $OpenXM: OpenXM/doc/issac2000/openxm-stackmachines.tex,v 1.7 2000/01/14 10:45:10 tam Exp $

% $OpenXM: OpenXM/doc/issac2000/openxm-stackmachines.tex,v 1.11 2000/01/16 06:39:39 takayama Exp $

\section{OpenXM Stack machines}\label{sec:ox-stackmachines} (Tamura)

\section{OpenXM Stack machines}\label{sec:ox-stackmachines}

In OpenXM specification, all servers are stack machines.

%These are called OpenXM stack machines.

When a server ox\_xyz gets an OX data message,

it translates the data into an object of its local mathematical system

it translates the data into a local object of ox\_xyz

and push the object on the stack.

and pushes the object onto the stack.

Following the OpenMath specification,

According to the OpenMath specification,

the translation scheme together with definitions of mathematical operations

the translation scheme

of the system ox\_xyz is called the {\it PhraseBook} of ox\_xyz.

%% together with definitions of mathematical operations

%% of the system ox\_xyz

is called the {\it PhraseBook} of ox\_xyz.

For example, the Asir command {\tt ox\_push\_cmo(P,1)}

(push integer $1$ onto the server $P$)

sends an OX data message

{\tt (OX\_DATA,(CMO\_ZZ,1))} to the server $P$.

Here,

{\tt OX\_DATA} stands for {\tt OX\_DATA} header and

{\tt (CMO\_ZZ,1)} is a body standing for $1$ expressed

by the CMO.

The server tranlates {\tt (CMO\_ZZ, 1)} to its internal object of

the integer $1$

and pushes the object onto the stack.

If the server gets an {\it OX command} message, then the server

executes the command.

Any OX command message starts with the int32 tag OX\_COMMAND.

The body is an OpenXM stack machine operation code expressed by int32.

The body is a stack machine operation code expressed by int32.

The codes are listed below.

The codes are listed below \cite{noro-takayama}.

\begin{verbatim}

#define SM_popSerializedLocalObject 258

#define SM_popCMO 262

Line 31 The codes are listed below.

Line 46 The codes are listed below.

#define SM_executeStringByLocalParserInBatchMode 274

#define SM_getsp 275

#define SM_dupErrors 276

#define SM_DUMMY_sendcmo 280

#define SM_sync_ball 281

#define SM_control_kill 1024

#define SM_control_to_debug_mode 1025

#define SM_control_exit_debug_mode 1026

Line 40 The codes are listed below.

Line 53 The codes are listed below.

\end{verbatim}

OpenXM does not have a standard for mathematical operation sets

while it is a work in progress in \cite{gap}.

while it is a work in progress in the GAP group \cite{gap}.

Each OpenXM server has its own set of mathematical operations,

which are performed as follows.

Mathematical operator name, such as {\tt fctr} (asir factorization command),

First, arguments for a mathematical operation

is pushed as a string,

and the number of the arguments are pushed.

the stack machine command

Second,

{\tt SM\_executeFunction} (269) pops the operator name, the number of arguments

the mathematical operator name,

and arguments, and

such as {\tt fctr} (the factorization command of Asir),

the OX stack machine evaluates the operator, and pushes the result onto the stack.

is pushed as a string.

Finally, the stack machine command

{\tt SM\_executeFunction} (269) evaluates the operator and

pushes the result onto the stack

after poping the operator name, the number of arguments

and arguments.

For example, the following code factorizes $x^{100}-1$ by calling

ox\_asir from asir.

{\tt ox\_asir} from Asir.

\begin{verbatim}

P = ox_launch();

ox_push_cmo(P,x^100-1); ox_push_cmo(P,ntoint32(1));

ox_push_cmd(P,269);

ox_push_cmo(P,"fctr"); ox_push_cmd(P,269);

Ans = ox_pop_cmo(P);

\end{verbatim}

When an error has occurred on an OpenXM server,

an error object is pushed to the stack instead of a result of the computation.

an error object is pushed onto the stack

instead of a result of the computation.

The error object consists of the serial number of the OX message

which caused the error, and an error message.

\begin{verbatim}

[341] ox_rpc(0,"fctr",1.2*x)$

[340] P = ox_launch()$

[342] ox_pop_cmo(0);

[341] ox_rpc(P,"fctr",1.2*x)$

[342] ox_pop_cmo(P);

error([8,fctr : invalid argument])

\end{verbatim}

OpenXM server won't send error messages to the client

except when it receives a SM\_pop* command.

except when it receives a {\tt SM\_pop*} command.

OX stackmachines works in the asynchronous mode which is similar

OX stackmachines work in the asynchronous mode which is similar

to X servers.

For servers for graphic applications, it is an advantageous feature.

For servers of graphic and sound applications,

It is also easy to emulate RPC and a web server for MCP \cite{iamc}

it may be an advantageous feature.

It is also possible to emulate RPC and a web server for MCP \cite{iamc}

on our asynchronous OX stackmachines.

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