This paper presents a new idea of developing parallel programs for clusters of SMP nodes using the Ada programming language. We show how to implement OpenMP in Ada and simplify programming of distributed memory applications using remote subprograms calls instead of complicated message passing

Stpiczyński, Przemysław

English

University of Maria Curie-Skłodowska (UMCS): Scientific e-Journals / Uniwersytet Marii Curie-Skłodowskiej: e-czasopisma naukowe

 Annales UMCS Informatica AI 1 (2003) 73-79 Annales UMCS Informatica Lublin-Polonia  Sectio AI http://www.annales.umcs.lublin.pl/  Ada as a language for programming clusters of SMPs  Przemysław Stpiczyński*  Department of Computer Science, Maria Curie-Skłodowska University  Pl. M. Curie-Skłodowskiej 1, 20-031 Lublin, Poland   Abstract This paper presents a new idea of developing parallel programs for clusters of SMP nodes us-ing the Ada programming language. We show how to implement OpenMP in Ada and simplify programming of distributed memory applications using remote subprograms calls instead of complicated message passing.  1. Introduction While the largest computers in the world are still built for the highest performance, they still cost tens of millions of dollars. Clusters made high performance parallel computing available to institutions with much smaller budgets. Now it is possible to use several workstations (for example PC's) connected by Fast Ethernet, Gigabit or Myrinet, as a single powerful computational resource. The Parallel Virtual Machine (PVM) system helps to develop parallel programs for such distributed memory architecture [1]. In 1993 Message Passing Interface (MPI) has been developed by researchers from Argonne National Laboratory and became a de-facto standard for message passing parallel computing. MPI provides a large set of communication subroutines including point-to-point communication, broadcasting and collective communication [2]. Often, nodes of such clusters are  SMP (symmetric multiprocessing) machines, which means that their architecture is based on tightly-coupled identical processors with access to a shared memory. The parallel nature of such machines is hidden from the user: an operating system is responsible for allocation of processor time to the programs when scheduling them to run. Moreover, such a kind of parallel architectures is easy to program. Until quite recently each vendor has provided its own set of commands to support writing parallel programs. All these approaches were quite similar with directives for                                                  * E-mail address: przem@hektor.umcs.lublin.pl  PDF created with FinePrint pdfFactory Pro trial version www.pdffactory.comPobrane z czasopisma Annales AI- Informatica http://ai.annales.umcs.plData: 04/08/2020 20:52:38UMCSmanaging parallel code execution; e.g. loop parallelizing directives, locks, barriers and other synchronization primitives inserted into codes written in Fortran or C. Recently OpenMP [3] emerged as a standard for code parallelization for shared memory parallel computers. Unfortunately, people who want to utilize fully clusters of SMPs have to combine two different standards: OpenMP for shared memory and MPI for distributed memory, which makes programs complicated. In this paper we show how to simplify developing programs for the clusters of SMPs using the Ada 95 programming language [4] with the Distributed System Annex [4, 5] and GLADE [6].  2. Ada and OpenMP “The language Ada was primarily designed for the production of large portions of readable, modular, portable, and maintainable software for real-time applications” [7], so why not use it for developing parallel programs? The answer is quite simple: when Ada was being designed [4, 8], the parallel computing was not popular and this explains why Ada does not provide constructs which would simplify parallel programming [9, 10]. However, Ada provides a very powerful mechanism for concurrent programming (tasks and rendezvous for synchronization) which can also be used for developing programs for parallel shared memory computers. Unfortunately, the use of tasks is rather complicated in comparison with simple extensions to Fortran and C provided by vendors producing parallel computers. OpenMP provides support for three basic aspects of parallel computing: specification of parallel execution, communicating between multiple threads, expressing synchronization between threads. In Fortran, OpenMP directives satisfy the following format:  !$omp directive name   optional clauses  Such an approach allows to write the same code for both single-processor and multiprocessor platforms. Simply, compilers which do not support OpenMP directives or that are working in a single-processor mode treat them as comments.   Example 1 Let us consider the following code for numerical integration:  1 1( ) ( )( ) ~ ( ) ... ( )2 2bo nnaf x f xf x dx h f x f x -æ ö» + + + +ç ÷è øò , where b ahn-=  and ,  0,..., .ix a ih i n= + =  An OpenMP code will look like this: PDF created with FinePrint pdfFactory Pro trial version www.pdffactory.comPobrane z czasopisma Annales AI- Informatica http://ai.annales.umcs.plData: 04/08/2020 20:52:38UMCS h=(b-a)/n   !$omp parallel do private(x) reduction(+:sum)  do j=1,n-1  x=a+j*h  sum=sum+f(x)  end do  sum=h*(sum+0.5*(f(a)+f(b)))  In this example the reduction(+:sum) clause is used. It instructs the compiler that the variable sum is the target of a sum reduction operation. The OpenMP uses the fork-join model of parallel execution. A program starts execution as a single process, called the master thread of execution, and executes sequentially until the first parallel construct is encountered. Then the master thread spawns a specified number of threads and becomes a “master” of the team. All statements enclosed by the parallel construct are executed in parallel by each member of the team. It is clear that OpenMP standard can be easily adopted to Ada and it should support the same functionality as OpenMP in Fortran and C. Thus, our proposal is to use the following format for OpenMP directives in Ada:  pragma omp; -- directive name   optional clauses  Now let us consider a few examples of OpenMP-Ada constructs. Note that other “non loop-based” OpenMP constructs like sections and explicit synchronization can be easily translated into Ada 95.  Example 2 The parallel constructs instructs a compiler to create a parallel region to execute lines between begin and end in parallel:    pragma omp; -- parallel   begin     -- lines of code to be executed in parallel     -- .......   end;  Example 3 The parallel for construct instructs a compiler to parallelize the execution of a for loop:    h:=(b-a)/float(n);   pragma omp; -- parallel for private(x) reduction(+:sum)   for j in 1..n-1 do loop     x:=a+float(j)*h;     sum:=sum+f(x); PDF created with FinePrint pdfFactory Pro trial version www.pdffactory.comPobrane z czasopisma Annales AI- Informatica http://ai.annales.umcs.plData: 04/08/2020 20:52:38UMCS  end loop;   sum:=h*(sum+0.5*(f(a)+f(b))); Analogously we can adopt all OpenMP constructs. It should be pointed out that our proposal for OpenMP-Ada (just like official OpenMP for Fortran and C) defines only a “potential” parallelism. The above examples can be complied with a standard Ada compiler and it produces no errors. We only get warnings that the pragma omp is unknown. Now let us observe that each OpenMP-Ada construct can be translated into well known pure Ada constructs which support concurrent programming (just like tasks synchronized by rendezvous).  Example 4 The parallel region construct from Example 2 should be translated into the following code:  declare   task type ompT1 is      -- define a local task type    entry Init(nr:in integer); -- which accepts rendezvous   end ompT1;   task body ompT1 is -- body of the task     myid : integer;   begin     accept Init(nr:in integer) do -- get the number       myid:=nr;     end Init;     -- lines of code to be executed in parallel     -- .......   end ompT1;   type refompT1 is access ompT1;   tref : refompT1; begin   for i in 0..AdaOpenMP.NPROCS-1 loop     tref:=new ompT1;   -- create a new task     tref.all.Init(i);  -- give the number to the task   end loop; end;  In the above example we define a local task type and use it to create a number of tasks (in the for loop). Each task gets its unique number and then starts to execute the code intended to be executed in parallel. It is clear that the OpenMP-Ada construct is much simpler.  3. Distributed computing with DSA As it was mentioned above, if we want to develop programs for clusters we have a choice: PVM or MPI. Both of the systems are based on the message passing. They are rather complicated and cannot be used together with Ada. On PDF created with FinePrint pdfFactory Pro trial version www.pdffactory.comPobrane z czasopisma Annales AI- Informatica http://ai.annales.umcs.plData: 04/08/2020 20:52:38UMCSthe other hand, Ada 95 offers much simpler way of writing distributed programs called remote subprogram calls defined in the Distributed System Annex (DSA) which is a part of the language definition [4]. A typical distributed application in Ada consists of several partitions executed on remote hosts. Each partition comprises a number of Ada packages categorized with simple Ada constructs. Such packages define “services” provided by remote hosts [5, 6]. From a programmer's point of view, calls to “remote subprograms” are quite similar to simple subprogram calls. It should be pointed out that DSA provides several interesting mechanisms just like distributed shared memory [6, 11].  Example 5 The categorized package Host_Pkg provides the function Integral. In the evaluation part of the package body one calls the routine Register from the package Main_Pkg} which is a part of the main partition.    with funct;   package Host_Pkg is      pragma Remote_Types;      type Host_handler is tagged limited private;      type RefToHandler is access all Host_handler'Class;      function Integral(h:Host_handler;a,b:in float;        n: in integer; f: funct.RefToFunct) return Float;   private      type Host_handler is tagged limited        record          myid:integer;        end record;   end Host_Pkg;  The main partition contains the following package:    with Host_Pkg;   package Main_Pkg is      pragma Remote_Call_Interface;      procedure Register(h:access Host_Pkg.RefToHandler);      ......... -- other serveces   end Main_Pkg;  The routine Integral can be called as follows:    with Host_Pkg; with Main_Pkg;   procedure Simple is   begin      .......      value:= Host_Pkg.Integral(handler,a,b,n,f); PDF created with FinePrint pdfFactory Pro trial version www.pdffactory.comPobrane z czasopisma Annales AI- Informatica http://ai.annales.umcs.plData: 04/08/2020 20:52:38UMCS     .......   end Simple;  In the above example, a distributed application starts with the main partition which contains the package Main_Pkg. Each remote partition “registers” its services to the main partition by providing a remote reference to its local data of the type Host_handler. When the main partition calls to the routine Integral, the request is dispatched to the partition which contains handler, where the routine is called. Then  the result goes back to the main partition.  Now let us consider the situation when a distributed application consists of several partitions with the package Host_Pkg}. Thus each partition can be responsible for computing the integral on a subinterval. Calls to remote copies of the subprogram Integral should be parallelized. Thus we can simply mix the proposed OpenMP-Ada with DSA.  Example 6 In this example we show how combine the proposed OpenMP-Ada with the mechanism of remote subprograms calls.    h:=(b-a)/float(AdaOpenMP.NHOSTS);   pragma omp; -- parallel for shared(h)   pragma omp; -- private(xa,xb) reduction(+:sum)   for j in 0..AdaOpenMP.NHOSTS-1 do loop     xa:=a+float(j)*h;     xb:=xa+h;     sum:=sum+Host_Pkg.Integral(handler(j),xa,xb,n,f);   end loop;  4. Conclusions and future work We have presented a new idea of developing parallel programs for clusters of SMP nodes using the Ada programming language. We have shown how to implement OpenMP in the pure Ada and simplify programming of distributed memory application using remote subprogram calls instead of complicated message passing. As the future work, we are planning to write OpenMP-Ada compiler using Aflex and Ayacc, which are Ada versions of well known tools lex and yacc.   References [1] Dongarra, J., et~al., PVM: A User's Guide and Tutorial for Networked Parallel Computing, MIT Press, Cambridge, (1994). [2] Pacheco, P., Parallel Programming with MPI, Morgan Kaufmann, San Francisco, (1996). [3] Chandra, R., Dagum, L., Kohr, D., Maydan, D., McDonald, J., Menon, R., Parallel Programming in OpenMP, Morgan Kaufmann Publishers, San Francisco, (2001). [4] Ada 95 Reference Manual, Intermetrics, (1995). PDF created with FinePrint pdfFactory Pro trial version www.pdffactory.comPobrane z czasopisma Annales AI- Informatica http://ai.annales.umcs.plData: 04/08/2020 20:52:38UMCS[5] Pautet, L., Tardieu, S., What future for the distributed systems annex?, ACM SIGADA Ada Letters, 19 (1999) 77. [6] Pautet, L., Tardieu, S., GLADE User's Guide, Free Soft Foundation (2001). [7] Kok, J., Parallel programming with Ada, Int. J. of Supercomp. Applic., 2 (1988) 100. [8] Ada Reference Manual, Intermetrics, (1983). [9] Paprzycki, M., Zalewski, J., Ada in distributed systems: An overview, Ada Letters, 17 (1997) 55. [10] Paprzycki, M., Zalewski, J., Parallel computing in Ada: An overview and critique, Ada Letters, 17 (1997) 62. [11] Kermarrec, Y., Pautet, L., A distributed shared virtual memory for Ada 83 and Ada 9X applications, In Engle, Jr., C.B., ed.: Proceedings of the Conference on TRI-Ada, Seattle, WA, USA, ACM Press, (1993) 242.  PDF created with FinePrint pdfFactory Pro trial version www.pdffactory.comPobrane z czasopisma Annales AI- Informatica http://ai.annales.umcs.plData: 04/08/2020 20:52:38UMCSPowered by TCPDF (www.tcpdf.org)

Ada as a language for programming clusters of SMPs

We present a new efficient parallel algorithm for solving the first order linear recurrence systems with constant coefficients which is equivalent to the problem of solving Toeplitz bidiagonal systems of linear equations. The algorithm is formulated in the terms of level 1 and 2 BLAS (Basic Linear Algebra Subprograms) routines AXPY and GER. We also discuss its platform-independent implementation with OpenMP and finally present the results of experiments performed on a dual processor Pentium III computer running under Linux operating system with Altas as an efficient implementation of BLAS. The sequential version of the algorithm is up to 2.5 times faster than a simple sequential algorithm

 Annales UMCS Informatica AI 1 (2003) 81-87 Annales UMCS Informatica Lublin-Polonia  Sectio AI http://www.annales.umcs.lublin.pl/  Fast solver for Toeplitz bidiagonal systems of linear equations  Przemysław Stpiczyński*  Department of Computer Science, Marie Curie-Skłodowska University,  Pl. M. Curie-Skłodowskiej 1, 20-031 Lublin, Poland  Abstract We present a new efficient parallel algorithm for solving the first order linear recurrence sys-tems with constant coefficients which is equivalent to the problem of solving Toeplitz bidiagonal systems of linear equations. The algorithm is formulated in the terms of level 1 and 2 BLAS (Basic Linear Algebra Subprograms) routines AXPY and GER. We also discuss its platform-independent implementation with OpenMP and finally present the results of experiments performed on a dual processor Pentium III computer running under Linux operating system with Altas as an efficient implementation of BLAS. The sequential version of the algorithm is up to 2.5 times faster than a simple sequential algorithm.  1. Introduction Let us consider the problem of solving the following system of linear equations  1 12 21 00 1 n nx ax acx acæ ö æ öæ öç ÷ ç ÷ç ÷- ç ÷ ç ÷ç ÷ =ç ÷ ç ÷ç ÷ç ÷ ç ÷ç ÷ç ÷ç ÷ ç ÷-è øè ø è øOM MO O. (1) The matrix of the system is a bidiagonal Toeplitz matrix wich means that entries are constant along each diagonal. The problem of solving (1) is equivalent to the problem of solving the following first order linear recurrence system with the constant coefficients  11for 1for 2,...,k k ka kxa cx k n-=ì= í + =î. (2) The problem (1) or alternatively (2) arises in several fields of scientific computing [1-3]. For example, the well known Horner's scheme [4] can be expressed in terms of (2). The equation (2) is also a critical part of some                                                  * E-mail address: przem@hektor.umcs.lublin.pl  PDF created with FinePrint pdfFactory Pro trial version www.pdffactory.comPobrane z czasopisma Annales AI- Informatica http://ai.annales.umcs.plData: 04/08/2020 21:00:42UMCSnumerical algorithms [5-7]. Unfortunately, optimizing compilers are not able to generate machine code which would fully utilize the underlying hardware, thus due to the Amdahl's law [8], such part of an algorithm can cause that the overall performance of a program will not be satisfactory. So it is very important to find an efficient method for solving the problem. Different algorithms for the solution of the problem (2) have been designed for parallel [9-14] and vector [15-18] computers. However these algorithms like cyclic reduction, Wang's method and recursive doubling [12] lead to a substantial increase in the number of floating-point operations [8], what makes them unattractive in a classical serial systems (just like Intel Pentium) or parallel computers with a limited number of processors. The aim of this paper is to present a new efficient algorithm for solving (1) based on a recently developed efficient algorithm for solving m-th order linear recurrence systems with constant coefficients [17, 19]. The algorithm is formulated in terms of level 1 & 2 BLAS (Basic Linear Algebra Subprograms) routines AXPY and GER [20, 8] and when an optimized version of BLAS is used (for example Atlas [21], then the algorithm is up to 2.5 times faster than a simple algorithm based on (2), even on one processor. Moreover, it can be easily parallelized on shared-memory parallel computers using OpenMP [5].  2. Divide and conquer approach First let us note that our problem (2) is a special case of the more general problem of solving m-th order linear recurrence system with the constant coefficients for n equations [13, 22,]  10 for 0for 1 ,mkk j k jjkxa c x k n-=£ìï= í + £ £ïîå  (3) which can be efficiently solved on different parallel and vector computers using the recently developed divide and conquer algorithm [14, 17, 19, 21]. Now let us briefly describe the divide and conquer algorithm for solving the first order linear recurrence systems with the constant coefficients (m=1). For the sake of simplicity, let us assume that there exist integers r and s such that rs = n. However, this assumption can be easily omitted: after we find rsx , we apply (2) to find 1,...,rs nx x+ . The recurrence equation (2) can be rewritten as the following block system of linear equations PDF created with FinePrint pdfFactory Pro trial version www.pdffactory.comPobrane z czasopisma Annales AI- Informatica http://ai.annales.umcs.plData: 04/08/2020 21:00:42UMCS 1 12 2x ax ax ar rLU LU Læ ö æ öæ öç ÷ ç ÷ç ÷ç ÷ ç ÷ç ÷ =ç ÷ ç ÷ç ÷ç ÷ ç ÷ç ÷ç ÷ç ÷ ç ÷è øè ø è øM MO O, (4) where ( )( )j 1 1x ,...,Tjsj sx x- += , ( )( )j 1 1a ,...,Tjsj sa a- += ÎRs and the matrices are given by  1 00 1ccæ öç ÷-ç ÷ç ÷ç ÷ç ÷-è øOO O, 0cU-æ ö= Îç ÷è ø Rs´s (5) The system (4) corresponds to the following recurrence system:  11 11 1j j-1x ax a x   for 2,..., .jLL L U j r-- -ì =ïí = - =ïî (6) When we consider the structure of the matrix T1 se eU c= - , where ke  denotes k-th unit vector of Rs and set 1jz a jL-= , then we get  1 1jx zx z y  for 2,..., ,j j j ra=ìïí = + =ïî (7) where 1j 1y eL-=  and ( )1j j scxa -=  for 2,...,j r= . The divide and conquer algorithm [13, 14] proceeds as follows. First we find (in parallel) all vectors kz  and y , then we find (sequentially) all coefficients ja  and numbers ( )1j sx - , 2,...,j r= . Finally (again in parallel) we calculate 1s -  first entries of jx , 2,...,j r= . Experimental results show that the algorithm achieves reasonable performance for a bigger number of processors [23].  3. BLAS-based algorithm In our earlier work [17] we have shown that the first step of the algorithm reduces to the problem of solving the following system of linear equations  LZ F= , (8) where L is given by (5) and  ( )1 rz ,..., z ,yTZ = , ( )1 r 1a ,...,a ,eTF = ÎRs´(r+1). The solution Z can be found row by row using the following vector-recurrence formula PDF created with FinePrint pdfFactory Pro trial version www.pdffactory.comPobrane z czasopisma Annales AI- Informatica http://ai.annales.umcs.plData: 04/08/2020 21:00:42UMCS 1,*,*,* 1,*for 1for 2,..., .k k kF kZF cZ k s-=ì= í + =î (9) where ,*kZ  and ,*kF $ denote the k-th row of Z and F respectively. Thus each row of Z can be computed using one call to the level 1 BLAS operation AXPY of the form x x+ ya¬ . Analogously, the last step of the algorithm can be expressed in terms of AXPY, which gives us a very fast algorithm for vector computers [17]. Unfortunately, in the case of scalar processors (just like Pentium III), the performance of the algorithm is comparable with the performance of a simple algorithm based on (2). The main idea of our new algorithm is to speed up the last step of the algorithm by using the routine GER from the level 2 BLAS. This routine is pretty much faster than the corresponding sequence of calls to the routine AXPY because it reduces the number of memory references in comparison with the number of arithmetic operations [8]. During the second step we collect the computed values of all coefficients ja  and compose the vector  ( )1u ,...,Tra a= ÎRr-1. (10) In the third (final) step, we compute the remaining 1s -  entries of all vectors x j , 2,...,j r= . It can be done by one call to the level 2 BLAS routine GER of the form xyTA A¬ + . Let ,x j , ,z j  and ,y j  denote 1s -  first entries of vectors x j , z j  and y  respectively. Then from (7) we get  , , ,j jx z yja= + . Now using (10) we conclude that the matrix ( ), ,2x ,..., x r ÎR(s-1)´(r-1) satisfies the following  ( ) ( ), , , , ,2 2x ,..., x z ,...,z y uTr r= + . (11) This algorithm can be easily parallelized on shared-memory machines. Namely, if we partition the matrices Z and F into blocks of columns, then (8) can be rewritten in the following form  ( ) ( )1 1,..., ,...,p pL Z Z F F=  (12) and each block jZ  can by calculated using (9). Thus, when p processors are available, each processor will be responsible for computing one block jZ . Similarly we can parallelize (11).  PDF created with FinePrint pdfFactory Pro trial version www.pdffactory.comPobrane z czasopisma Annales AI- Informatica http://ai.annales.umcs.plData: 04/08/2020 21:00:42UMCS4. Performance analysis and results of experiments Now let us study some basic facts on the complexity of the considered algorithms. It is clear that the simple algorithm based on (2) required 2 2n -  floating point operations (“flops”).  Proposition 1 The number of floating-point operations required by the sequential BLAS-based algorithm is  ( ),1 , , 2 2 2 4 2BLAST n r s rs r s n= - + - + . (13)  Fig. 1. Performance (in MFlops) od the sequential BLAS-based algorithm  for various s and n=42500  Proof. After we choose the integers r and s, we perform a sequence of 1s -  calls to the operation AXPY. In the second step we find last entries of 1r -  vectors 2x ,..., x r .  The third step consists of ( )2 1r r-  flops. Finally we find the numbers 1,...,rs nx x+  using (2). Thus  ( ) ( )( ) ( ) ( ) ( ),1 , , 2 1 1 2 1 2 1 2BLAST n r s r s r s r n rs= + - + - + - + - .  The method has been implemented in FORTRAN 77 and OpenMP [24] and tested on a dual processor Pentium III 866MHz computer running under Linux operating system. We have used Atlas [21] as the optimized version of BLAS and Omni OpenMP compiler to express the parallel execution of (12). The algorithm has been tested varying the problem sizes n and values of the parameter s. To discover an asymptotic behavior of the algorithm we have PDF created with FinePrint pdfFactory Pro trial version www.pdffactory.comPobrane z czasopisma Annales AI- Informatica http://ai.annales.umcs.plData: 04/08/2020 21:00:42UMCSdecided to run our program not only for small degree systems but also for very large degree. The wall clock time has been measured using the routine omp_get_wtime(). Results of the experiments can be summarized as follows. 1. The BLAS-based algorithm is faster than the simple algorithm based on (2) for n>500. However, the algorithm could be much faster on computer systems where the performance of AXPY and GER is relatively high. 2. The BLAS-based algorithms (both sequential and parallel) achieve the best performance for the value of the parameter 2s n» . 3. The sequential BLAS-based algorithm is up to 2.5 times faster than the simple algorithm based (Figure 2). The use of the parallel BLAS-based algorithm is profitable for great problem sizes (n>40000). 4. For smaller values of n, the whole coefficient vector can be stored in the processor cache (Pentium III has 256KB cache). For n>45000 the performance of all algorithms rapidly decreases. This is caused by cache misses.  Fig. 2. Performance (in MFlops) of the BLAS-based algorithm for various n  References [1] Li L., Hu J., Nakamura T., A simple parallel algorithm for polynomial evaluation, SIAM J. Sci. Comput., 17 (1996) 260. [2] Munro I., Paterson M., Optimal algorithms for parallel polynomial evaluation, J. Comput. System Sci., 7 (1973) 189. [3] Swann H., On solenoidal high-degree polynomial approximations to solutions of the stationary Stokes equations, Numer. Methods Partial Differ. Equations, 16 (2000) 480. [4] Stoer J., Bulirsh R., Introduction to Numerical Analysis, Springer, New York, (1993). [5] Abu-Shumays I., Comparison of methods and algorithms for tridiagonal systems and for  vectorization of diffusion computations, In: Numrich, R., ed., Supercomputer Applications, New York, Plenum Press, (1985). [6] Guitart J., Ruiz-Moreno S., Strict calculation of the light statistics at the output of a travelling wave optical amplifier, Elecronics Letters, 29 (1993) 1589. PDF created with FinePrint pdfFactory Pro trial version www.pdffactory.comPobrane z czasopisma Annales AI- Informatica http://ai.annales.umcs.plData: 04/08/2020 21:00:42UMCS[7] Larriba-Pey J.L., Navarro J.J., Jorba A., Vectorized algorithms for natural cubic spline and B-spline curve fitting, In: Proceedings of PDP'96 Braga., (1996), 385. [8] Dongarra J., Duff I., Sorensen D., Van der Vorst H., Solving Linear Systems on Vector and Shared Memory Computers, SIAM, Philadelphia, (1991).  [9] Carlson D.A., Solving linear recurrence systems on mesh-connected computers with multiple global buses, Journal on Parallel and Distributed Computing, 8 (1990) 89. [10] Gajski D., Processor array for computing linear recurrence systems, In: Preceeding of the International Conference on Parallel Processing., (1978) 246. [11] Greenberg A., R.E.Lander, Paterson M., Galil Z., Efficient parallel algorithms for linear recurrence computation, Inf. Proc. Letters, 15 (1982) 31. [12] Larriba-Pey J.L., Navarro J.J., Jorba A., Roig, O., Review of general and Toeplitz vector bidiagonal solvers, Parallel Computing, 22 (1996) 1091. [13] Paprzycki M., Stpiczyński P., Parallel solution of linear recurrence systems, Z. Angew. Math. Mech., 76 (1996) 5. [14] Stpiczyński P., Parallel algorithms for solving linear recurrence systems, Lecture Notes in Computer Science, 634 (1992) 343. [15] Axelsson O., Eijkhout V., A note on the vectorization of scalar recursions, Parallel Computing, 3 (1986) 73. [16] Hafner H., Shonauer W., Investigation of different algorithms for the first order recurrence, Supercomputer, 40 (1990) 34. [17] Stpiczyński P., Paprzycki M., Fully vectorized solver for linear recurrence systems with constant coefficients, In: Proceedings of VECPAR 2000-4th International Meeting on Vector and Parallel Processing, Porto, June 2000, Facultade de Engerharia do Universidade do Porto, (2000) 541. [18] Van Der Vorst H.A., Dekker K., Vectorization of linear recurrence relations, SIAM J. Sci. Stat. Comput., 16 (1989) 27. [19] A new message passing algorithm for solving linear recurrence systems, Lecture Notes in Computer Science, 2328 (2002) 466. [20] Anderson E., Bai Z., Bischof C., Demmel J., Dongarra J., Du Croz J., Greenbaum A., Hammarling S., McKenney A., Ostruchov S., Sorensen D., LAPACK User's Guide, SIAM, Philadelphia, (1992). [21] Whaley R.C., Petitet A., Dongarra J.J., Automated empirical optimizations of software and the ATLAS project, Parallel Computing, 27 (2001) 3. [22] Modi, J., Parallel Algorithms and Matrix Computation, Oxford University Press, Oxford, (1988). [23] Paprzycki M., Stpiczyński P., Solving linear recurrence systems on the Cray Y-MP, Lecture Notes in Computer Science, 879 (1994) 416. [24] Chandra R., Dagum L., Kohr D., Maydan D., McDonald J., Menon R., Parallel Programming in OpenMP, Morgan Kaufmann Publishers, San Francisco, (2001).  PDF created with FinePrint pdfFactory Pro trial version www.pdffactory.comPobrane z czasopisma Annales AI- Informatica http://ai.annales.umcs.plData: 04/08/2020 21:00:42UMCSPowered by TCPDF (www.tcpdf.org)

Fast solver for Toeplitz bidiagonal systems of linear equations

https://journals.umcs.pl/ai/article/download/2923/2119

Ada as a language for programming clusters of SMPs

Abstract

Similar works

Full text

Available Versions

University of Maria Curie-Skłodowska (UMCS): Scientific e-Journals / Uniwersytet Marii Curie-Skłodowskiej: e-czasopisma naukowe

University of Maria Curie-Skłodowska (UMCS): Scientific e-Journals / Uniwersytet Marii Curie-Skłodowskiej: e-czasopisma naukowe