KR0123855B1 - The method of parallel processing for one to master slave - Google Patents

Abstract

setting an initial value to the variables related to an object system; instructing some work from a master CPU to a specific slave CPU; interrupting the master CPU after performing the instructed work and recording the result in a DPRAM; and setting the job pointer for the work instruction structure as "0" when the work instructed to the slave CPU is completed.

Description

Parallel Processing Method in One-to-Many Master-Slave Computing Units

1 is a schematic device diagram of a conventional one-to-many master-slave computer system.

* Explanation of symbols for main parts of the drawings

11: master CPU

12a, 12b, 12r, 12s: slave CPU

13a, 13b, 13r, 13s: DPRAM

The present invention installs a plurality of central processing units (CPUs) in one main body, one of which executes a main program, and the other CPUs are called only as functional functions, and are one-to-many master-slave. In particular, the present invention relates to a parallel processing method in a method computing device, and in particular, to a parallel processing method in a one-to-many master-slave computing device that can easily program a desired task without using a separate programming language for parallel processing. will be.

Typically, a master-slave computer system installs a large number of CPUs in one main body, one of which executes a main program, and the other CPUs constitute a one-to-many master-slave system that functions only as a functional function. There are many cases.

1 of the accompanying drawings shows an example of such a conventional one-to-many master-slave computer system.

Referring to this, in the conventional one-to-many master-slave computer system 10, as illustrated, a plurality of slave CPUs 12a, 12b, 12r, and 12s are connected to one master CPU 11, and Dual Ported Random Access (DPRAM) is shown. Memory: 13a, 13b…, 13r, 13s). At this time, the DPRAMs 13a, 13b, 13r, and 13s can bidirectionally reference and write, and have a function of transmitting interrupt signals in both directions. Therefore, each CPU is interrupted through DPRAMs 13a, 13b, 13r, and 13s, and the interrupt vector function contains code for communicating with the CPU that sent the interrupt and performing a specific task. Here, of course, the interrupted master CPU has a circuit configured to know which CPU sent the interrupt. At this time, the interrupted CPU records in advance the contents of the task to be instructed at the predetermined positions on the DPRAMs 13a, 13b, 13r, and 13s. In addition, the CPU which has completed the work leaves the contents of the result in a promised position on the DPRAMs 13a, 13b ..., 13r, 13s if necessary. As a result, this system configuration allows multiple CPUs to parallelize different tasks simultaneously for one purpose.

However, such a one-to-many master-slave computer system of the prior art is in fact very difficult to program and execute a desired task using such a system unless a person skilled in parallel processing programming. This is because most executable programs are based on a sequential programming language, and a programming language for parallel processing is used only by extremely limited experts. After all, if you choose to use a sequential language, you will have to do a whole system-level preparation. Without this, programming can be time-consuming and expensive. In addition, in the conventional method, when checking the completion of work on a slave CPU, the number of the slave CPU must be known, a part of reading the return factors must be programmed, and the source code length is increased. There are many drawbacks to code that can be confusing.

SUMMARY OF THE INVENTION The present invention has been made in view of the above problems, and provides a parallel processing method in a one-to-many master-slave type computing device that can easily program a desired task without using a separate parallel programming language. The purpose is to provide.

In order to achieve the above object, a parallel processing method in a one-to-many master-slave operation unit according to the present invention comprises the steps of: setting initial values to variables related to a target system; Performing the indicated operation, writing the result to DPRAM, interrupting to the master CPU, and when the instruction instructed to the slave CPU is completed, the pointer variable for the job instruction structure is set to 0 ( It is characterized by the fact that it includes a zeroing step.

By using pointer variables in this way, there is no need to remember the number of a specific slave CPU, object-oriented programming can be done by defining variable names appropriate to the nature of the task, and shortening the source code length of an application program. There is an advantage.

Hereinafter, exemplary embodiments of the present invention will be described in detail with reference to the accompanying drawings.

In summary, the final product of the present invention can be compressed into two program modules.

The first is a module for the master CPU, which runs in link with the user's application.

The second is a module for each slave CPU, which runs on its own and can further link application functions to expand the type of work according to the user's wishes. We will call these two modules master and slave modules, respectively.

Here, the operation of the master module is performed in the following order.

First, initial values are set to variables related to the initialization step.

That is, CmdStat [all] = CMDSTAT-NONE:

SysJobPtr [all] = 0

It then instructs a particular slave CPU to do something. When the job completes, the slave CPU interrupts the master CPU so that the master CPU reads the result from the DPRAM and zeroes the pointer variable (called the job pointer) to the work instruction structure. In this series of operations, the virtual program and C ++ language used in the system are as follows.

Data type and constant definition of master module

typedef enum {CMDSTAT-NONE, CMDSTAT-BUSY} T-CmdStat;

# define ENDOFARG －

# define CHARARG ～

# define INTARG ∼

# define LONGARG －

# define FLOATARG ～

# define DOUBLEARG ～ ※ Used by AlocJP ()

# define CHARPTRARG ～

# define INTPTRARG ～

# define LONGPTRARG ～

# define FLOATPTRARG ∼

# define DOUBLEPTRARG ∼

# define POSTJOB ～

typedef struct T-JP * T-JobPtr: / * Pointer type for the structure

struct T-JP / * Job structure * /

{void (* postjob) (T-JobPtr jp, int which): / * Post-processing function * /

char * char-arg; / * Return argument list * /

int * int-arg;

long * long-arg;

float * float-arg;

double * double-arg;

char ** charptr-arg;

int ** intptr-arg;

long ** longptr-arg;

float ** floatptr-arg;

double ** doubleptr-arg; };

Variable definition of master module

T-CmdStat CmdStat [N]; / * Save slave CPU busy * /

T-JobPtr * SysJobPtrPtr [N];

l / * array of pointers to pointer variables that point to structures describing operations allocated to each slave CPU * / l

Function definition in master module

void Write Dpram (int which, int offset, int data);

int Read Dpram (int which, int offset);

int Check Intr (void); / * -1 * / if returning the number of the slave CPU that sent the interrupt

void Call Slave CPU (int which, int jobid, T-JobPtr * jp, int Indent argsize, int * arglist): This is a function that instructs the slave CPU to execute the job in the following order.

1) Wait until Cmdstat [which] == CMDSTAT-NONE

2) Cmdstat [which] -CMDSTAT-BUSY;

3) Write Dpram (which, 0, argsize);

4) Write Dpram (which, i + 1, arglist [i]);

5) SysJobPtrPtr [which] = jpp;

6) Write Dpram (which, PCINTDSP, jobid); * /

int ScanArgSize (int which); / * == {Read Dpram (which, 0); * / scan | offset [which] -0;} * /

int ScanArgList (int which); / * == Read Dpram (which, scanoffset | [which] ++) * /

T-JobPtr AllocJP (int firstarg,…);

On the other hand, the function to allocate the Job Pointer structure and return the pointer is as follows.

T-JobPtr jp1, jp2;

float ret;

jp1-AllocJP (ENDOFARG); If no return argument is required

jp2 AllocJP (POSTJOB, postfunc, INTARG, 2, 0, 1 FLOATPTRARG, 1, indentret, ENDOFARG); / * If we use postfunc as a post-processing function and 0,1 as the argument and ret as the indent return argument, * /

Here, the functions are only necessary for librarying using a master module, and do not need to be known in a program using an actual library.

Interrupt Vector Function of Master CPU

void MasterIntrVector (…)

{int jobid, which;

begin;

which = Check Intr ();

jobid = Read Dpram (which, DSPINTPC);

Cmdstat [which] = CMDSTAT-NONE;

if (SysJobPtrPtr [which])

{if (SysJobPtrPtr [which] → postjob)

SysJobPtrPtr [which] → postjob (* SysJobPtrPtr [which], which); / * Postprocess function * /

* SysJobPtrPtr [which] = 0; / * zero the job pointer variable

* / SysJobPtrPtr [which] = 0; }

if ((which = Check Intr ()) -1 / * Handle requests coming in during vector execution * /}

So far, we have looked at the operation of the master module and the definitions of functions and variables related to it.

Now, the slave module will be described.

The operation of the slave module can be summarized as follows in order.

As in the operation of the master module, in the initial initialization stage, the initial values of related variables are set first.

That is, JobFunc [all job id's] = all job funstions;

JobId = 0;

When the initial value setting is completed as described above, it performs the operation instructed by the master CPU, writes the result in DPRAM, and interrupts the master CPU.

1) First read the JobId from the interrupt vector function. (See Interrupt Vector Function of Slave CPU.)

2) Then return to the main function and call it. (See Function Definition of Slave Module)

3) Within the function, the parameters passed by the master CPU are read through the DPRAM, the task is executed, the results are written in the DPRAM, and the interrupt is sent to the master CPU. In this series of operations, the virtual program and C ++ language used in the system are as follows.

Variable Definition of Slave Module

int JobId;

void (* Job Func [NUM-JOB]) (void);

Function definition of slave module

void main (void)

{JobId = 0

while (1) / * JobId is * / in Interrupt Vector

if (JobId) / * read the value * /

JobFunc (JobId) ();

JobId = 0;

Write Dpram (DSPINTPC, DSP-CMDINT); }

Interrupt Vector Function of Slave CPU

void SlaveIntrVector ()

{JobId = Read Dpram (PCINTDSP); }

Instruction process of work on the master CPU

When building a function in a library using a master module, the following steps are taken:

1) Assign JodPointer jp.

2) Copy the necessary arguments to arglist [].

3) callSlaveCPU (which, jobid, jp, argsize, arglist);

Execution of work on slave CPUs

The execution order of function functions assigned to JobFunc [jobid] is as follows.

1) Read argsize (in DPRAM)

2) Read the arguments (in DPRAM)

3) Perform the desired task.

4) Write the return result to DPRAM.

As described above, the parallel processing method in the one-to-many master-slave operation unit according to the present invention does not need to remember the number of a specific slave CPU by using a Job Pointer variable, and defines a variable name suitable for the nature of the job. This allows you to do object-oriented programming, and the return argument is automatically read into the designated variable upon completion of the task, so you don't have to program it in order to get the return argument as usual. You can further simplify your program by reducing the length of your program's source code.

Claims (2)

Setting an initial value to variables related to the target system, instructing a specific slave CPU from a predetermined task, performing a designated task, writing a result to DPRAM, and interrupting the master CPU. In the one-to-many master-slave operation unit, characterized in that it comprises the step of zeroing a pointer variable (job pointer) for the work instruction structure when the job instructed to the slave CPU is completed. Parallel processing method. The method of claim 1, wherein the master CPU stores the contents of the task to be instructed to the slave CPU, the result to be returned, and whether the task is completed as a structure and variable data indicating the same and included in the function for the instruction of the task. A parallel processing method in a one-to-many master-slave type computing device, characterized in that it is included as part of a drive program of a module having a method of calling.