=Paper=
{{Paper
|id=Vol-1973/paper17
|storemode=property
|title=Templet Web: the experimental use of volunteer computing approach in scientific Platform-as-a-Service implementation
|pdfUrl=https://ceur-ws.org/Vol-1973/paper17.pdf
|volume=Vol-1973
|authors=Sergei Vostokin,Yuriy Artamonov,Danil Tsarev
}}
==Templet Web: the experimental use of volunteer computing approach in scientific Platform-as-a-Service implementation==
https://ceur-ws.org/Vol-1973/paper17.pdf
Templet Web: The Experimental Use of Volunteer
Computing Approach in Scientific Platform-as-a-Service
Implementation
Sergei Vostokin Yuriy Artamonov Danil Tsarev
Samara University, Samara, Russia
vostokin sv@ssau.ru
Abstract
This article presents the Templet Web cloud service [a1]. The service
is designed for high-performance scientific computing automation.
The use of high-performance technology is specifically required by
new fields of computational science such as data mining, artificial
intelligence, machine learning, and others. Cloud technologies provide
a significant cost reduction for high-performance scientific applications.
The main objectives to achieve this cost reduction in the Templet
Web service design are: (1) the implementation of “on-demand”
access; (2) source code deployment management; (3) high-performance
computing programs development automation. The distinctive feature
of the service is the approach mainly used in the field of volunteer
computing, when a person who has access to the computer system
delegates his access rights to the requesting user. We developed
an access procedure, algorithms, and software for utilization of free
computational resources of the academic cluster system in line with
the methods of volunteer computing. The Templet Web service has
been in operation for five years. It has been successfully used for
conducting laboratory workshops and solving research problems, some
of which are considered in this article. The article also provides an
overview of research directions related to the service development.
Keywords: Cloud Computing, Platform as a Service, Volunteer Com-
puting, Scientific Computing, Automatic Parallel Programming, Clus-
ter Computing
1 Introduction
Modern mathematical modeling is based on numerical methods. Of all the numerical methods, the methods that
are implemented exclusively in high-performance computing systems are becoming increasingly popular. Thus,
the development of data mining or deep machine learning is fundamentally impossible without the use of high-
performance technology. Moreover, rejecting high-performance parallel computing when sequential computing
may be implemented can lead to incorrect results. For example, it is possible to get an incomplete study of a
Copyright c by the paper’s authors. Copying permitted for private and academic purposes.
In: E. Ivashko, A. Rumyantsev (eds.): Proceedings of the Third International Conference BOINC:FAST 2017, Petrozavodsk, Russia,
August 28 - September 01, 2017, published at http://ceur-ws.org
129
model’s parametric space; to get an incorrect conclusion about the properties, adequacy and boundaries of the
applicability of the model to the studied object.
Despite the affordability and widespread use of high-performance computing hardware, such as multi-core
processors, general-purpose GPUs, and cluster-based systems, the developers of numerical models often imple-
ment the models in the form of a traditional sequential program. We may presuppose the following three reasons
for this limited use of high-performance computing.
Firstly, it is important to access high-performance resources “on demand” in low-budget projects, preliminary
studies, or training. At the same time, the access to high-performance academic systems is usually associated
with bureaucratic procedures and is not implemented remotely via the Internet. The offline access registration
entails financial costs and time loss when renting computing power.
Secondly, the usual form of access to computing resources for the high-performance computing industry is
terminal access over a secure channel based on SSH protocols. Along with great flexibility, which is an advantage
for a system programmer, this form of access is inconvenient for a mathematician. It requires him to master
the skills of system administration that are not typical professional skills for a numerical modeling expert. This
leads to an increase in the expenditure of time and finances for the organization of calculations on the model.
Finally, an equally important problem is the development of a parallel program for a numerical algorithm.
The traditional form of the representation of a numerical algorithm is a sequential program representation. This
algorithmic representation is natural for the mathematician. However, at present, the theory of compilation
gives no universal methods of transforming the algorithmic representation into binary code suitable for practical
use in high-performance systems. Therefore, modern tools for the development of high-performance computing
programs require an explicit description of simultaneously performed calculations and taking into account the
hardware features of the computing equipment. The study of programming tools and equipment features involves
time and financial costs.
Modern mathematical modeling is used primarily for applied problems. Thus, reduction of the financial
and time cost factors for setting up experiments with the models is practically important. In this regard, the
motivation for our research in cloud computing service development is the problem of complex automation. The
aim of automation is to reduce the negative role of factors considered above. This automation includes: (1) the
automation of the access procedure for a high-performance system; (2) the automation of program deployment
(code upload, building, starting, and control of the program execution, downloading the results); (3) automatic
parallel programming for high-performance computing systems.
2 Research Methods
Development and maintenance of a service with the requirements stated above are associated with solving many
technical and scientific problems. The core of our strategy of providing access to a remote computing system is
the concept of volunteer computing [WTWB+ 97]. The donors of computing resources in our system are academic
cluster account holders. The system is implemented as PaaS (platform as a service) cloud service [MG11]. In
this approach, the infrastructure that implements and provides the service is completely hidden from the user,
and it is possible to work with the service using just a web browser.
The specifics of access to computing resources lead us to the need of solving the problem of forecasting the
computational load of the cluster. A user who provides the access to a cluster should know the periods when
the access can be granted without compromising his/her own projects and the overall cluster load. At the same
time, a user who gets the access needs to know when the effective work on the cluster will be possible. In order
to solve this problem, mathematical methods of forecasting and data mining are used [HKP11, MWH98].
Automation of parallel programming in our service is based on the concept of algorithmic skeletons [Col04,
GVL10]. This method implies the storage of a set of frameworks for controlling parallel computations. The
frameworks can be extended with sequential code for a task. To specify the semantics of parallel execution for
the algorithmic skeletons, we apply the version of the actor model [Vos16] and define the model in the temporal
logic of actions [Lam94]. The syntax of skeletons is developed according to the language-oriented programming
approach [War95], considering the maximum compatibility with development environments and tools that are
traditional for high-performance computing (C++, OpenMP, MPI).
Below we consider the technologies developed and tested in the service, statistical data on its functioning,
and numerical modeling tasks solved with the help of it. In conclusion, the results of service development are
summarized.
130
3 On-demand Access to Academic Cluster
Our service uses the idea of volunteer computing to access a remote computer system. A Volunteer is a person
who has an account on a remote system accessible via the SSH protocol. A Consumer is a person who does
not have an account on the remote system, but wants to use the Volunteer’s account. To run the Consumer’s
program through the Volunteer’s account, our service implements the following protocol:
• Consumer submits the program source code and input data to Volunteer;
• Volunteer runs the program on his/her own behalf on the remote system;
• Volunteer returns result of the run to Consumer.
The system acts as a broker and assumes the following obligations:
• storing of source code, data and the result of computations for mutual audit of Consumers and Volunteers
actions;
• organizing the access to this information by both Volunteer and Consumer;
• multiplexing access for many Consumers to the same Volunteer account.
Each Consumer can interact with an arbitrary number of Volunteers; each Volunteer can simultaneously provide
access to his remote system for an arbitrary number of Consumers. The roles of the Consumer and the Volunteer
can be entitled to one and the same person.
Unlike the traditional BOINC [And04] volunteer computing middleware, in our implementation, multiplexing
is used when connecting to Volunteer, not to Consumer. It is also assumed that the Volunteer gives access to a
multitasking system (for instance, batch system).
Thus, if Volunteer trusts Consumer and knows his identifier in our system, he can immediately grant access
to the Consumer.
4 Deployment Automation
Three entities are involved in managing the deployment of user programs on a cluster: Task, Template, and
Environment.
A Task is the main entity of the system. The attributes of a task are the code of the Customer program, the
input data, the output data and the execution status. The Task is generated from the Template.
Each Template contains sample code that users can adapt to their algorithm; the script that controls the
assembly of the Task on the Volunteer system; there are also a start script and the script for downloading the
results. Any Template can be used to create many Tasks. Each Task is related to one Template.
Task is performed in an Environment. Each Environment contains information for connecting to the Volunteer
system. Environment implements the life cycle of Tasks in Volunteer system. Specific operations of the life cycle
are defined in the Template. For example, Environment defines the moment when the program is started on the
Volunteer system and runs the build.sh script specified in the Template.
The system has additional entities that are used to manage access rights and implement collaboration scenarios.
The main scenarios include the work of a student group and the work of a research group on a cluster. You can
grant access to one or more computing clusters to a group of students and monitor their work. The students can
perform individual or group projects. The working in a project can be conducted using the browser or a version
control system.
5 Automatic Parallel Programming
Let us demonstrate automatic parallel programming in our system using the example of a computation by the
master-workers scheme. This scheme is typical for volunteer computations in BOINC. When you create Tasks
from the master-workers Template, the user is given the following code sample (some details are omitted).
struct task{/*-to be filled by the user-*/};
struct result{/*-to be filled by the user-*/};
struct bag{
bool get(task*t){/*-to be filled by the user-*/}
131
void put(result*r){/*-to be filled by the user-*/}
/*-to be filled by the user-*/
};
void proc(task*t,result*r){/*-to be filled by the user-*/}
int main(int argc, char* argv[])
{
bag b;
/*-to be filled by the user-*/
b.run();
/*-to be filled by the user-*/
return EXIT_SUCCESS;
}
Here, struct task is the input data of the task; struct result is the result of the calculation of the task; proc
is the procedure for calculating the task performed by the workflow; struct bag is a state and methods of the
master process; get is a method for creating a new task or informing that there are no tasks; put is a method
for recording the result of calculating a task in a master process.
The user fills in the parts marked with the comment /*-to be filled by the user -*/, with his/her
sequential code. The resulting skeleton can be compiled and checked for syntactical correctness in the usual way.
The algorithm for converting the skeleton into executable code for volunteer system architecture is contained in
Template. The system implements the conversion of this skeleton into the code to be executed in the shared
memory using OpenMP and into the code for distributed execution using MPI [VT17].
The master-workers skeleton can be used to prototype the applications for the BOINC platform. Note that the
integration of BOINC with cluster systems was studied earlier in the CluBORun project [ABM+ 15, ZMK+ 17].
In the future, it is possible to run master-workers applications from our system to the BOINC network, if we
consider the BOINC control node as special type of Volunteer system.
Other skeletons, for example pipeline, are also implemented in our system. Our system has a DSL-based
constructor for developing skeletons in the form of actor networks.
6 Results of Service Operation
The Templet Web service is deployed in the private cloud of the Supercomputer Center of Samara University [a15].
The service is used for teaching students high-performance programming, for automatic parallel programming
technologies research, and for solving applied problems using numerical algorithms [AV15].
Most users are bachelor’s and master’s degree students. Students act as the Consumers of the service. Teachers
who have accounts on the “Sergey Korolev” cluster act as the Volunteers providing resources for temporary access.
The dynamics of user growth is shown in Table 1.
Year Total in the period Accumulated total
2013-2015 212 212
2016 63 278
2017 (first six months) 88 366
Table 1: The dynamics of Templet Web user growth
Table 2 shows the number of tasks running on the “Sergey Korolev” cluster during the period of operation
of the Templet Web system. This number of tasks is multiplexed through three accounts on the cluster and one
account on a test low-power Linux system.
Year Total in the period Accumulated total
2013-2015 141 141
2016 2597 2738
2017 (first six months) 1308 4046
Table 2: The number of task runs on Templet Web system
Users develop tasks in projects. The project allows you to control access to Environments and Tasks for a
group of users. Table 3 shows the dynamics of creating projects in the system.
132
Year Total in the period Accumulated total
2013-2015 153 153
2016 126 279
2017 (first six months) 237 516
Table 3: The dynamics of creating projects in Templet Web system
In 2016, the function of editing code in a web browser was added to the system. As you can see from Tables 2-4,
this function is in demand among users and increased the intensity of Templet Web usage. Projects are basically
created with the ability to edit the code in the browser.
Year Total in the period Accumulated total
2013-2015 0 0
2016 97 97
2017 (first six months) 226 323
Table 4: The number of Templet Web projects managed exclusively in browser
The system includes a universal skeleton constructor based on the Templet markup language [Vos16]. The
source code for the skeleton constructor and examples of its use are available online [a17].
An important part of the service is the subsystem for monitoring and forecasting the load of the ”Sergey Ko-
rolev” cluster. It implements a 12-hour forecast of changing the cluster load, calculated by various mathematical
methods: maximum likelihood method [Art16], neural networks [and17], an adaptive combination of the listed
methods [Art17]. The forecasting system is implemented using the microservice approach [AV16].
We use Templet Web system to solve problems in modeling the dynamics of space vehicles. The study of
dynamics includes the numerical solution of the equations of spacecraft motion with different initial conditions,
the construction of phase trajectories and Poincaré maps. The aim of the study is to identify chaotic processes
and unstable modes in operation of the spacecraft orientation systems. This class of models is realized by the
above-described scheme of master-workers calculations [VDA16].
In this project, we also examined the applicability of the master-workers scheme to parallel algorithms im-
plementation for training neural networks with the selection of the optimal structure of neurons in hidden
layers [Lit14]. A program for parallel continuous wavelet transform has been developed in the course of the
study of the problem of analysis of acoustic signals from a cutting tool [SVP17].
7 Conclusion
The experience we have gained from the development and operation of the Templet Web system shows the
practical importance of a comprehensive approach to automating high-performance computing in mathematical
modeling. This approach includes the automation of programming, on-demand access to resources and the
automation of deployment. The PaaS implementation of the Templet Web system is accessible through a
standard web browser. This design significantly reduced the complexity of a cluster system for users and led
to an increase of cluster usage. The technology of providing access to the computer system by the principles of
volunteer computing has made it possible to simplify cluster administration considerably in the organization of
the educational process using the resources of the Supercomputer Center of Samara University.
Acknowledgments
This work is partially supported by the Russian Foundation for Basic Research (RFBR No. 15-08-05934-A), and
by the Ministry of Education and Science of the Russian Federation in the framework of the State Assignments
program (No. 9.1616.2017/PCh).
References
[a1] The templet project. http://templet.ssau.ru/.
[a15] Supercomputing center of samara university. templet web. http://hpc.ssau.ru/node/3130/.
[a17] The templet markup language: a tool for concurrent, actor-oriented, skeleton programming.
https://github.com/templet-language.
133
[ABM+ 15] A. P. Afanasiev, I. V. Bychkov, M. O. Manzyuk, M. A. Posypkin, A. A. Semenov, and O. S. Zaikin.
Technology for integrating idle computing cluster resources into volunteer computing projects. In
5th International Workshop on Computer Science and Engineering: Information Processing and
Control Engineering, WCSE 2015-IPCE, 2015.
[And04] David P. Anderson. Boinc: A system for public-resource computing and storage. In Proceed-
ings of the 5th IEEE/ACM International Workshop on Grid Computing, GRID ’04, pages 4–10,
Washington, DC, USA, 2004. IEEE Computer Society.
[and17] Yuriy S. Artamonov and. Prediction of cluster system load using artificial neural networks. In
Data Science. Samara University, 2017.
[Art16] Y.S. Artamonov. Using the emmsp model to predict the available computing resources in the
cluster systems (in russian). Proceedings of the Samara Scientific Center of the Russian Academy
of Sciences, 18(4(4)):681–687, 2016.
[Art17] Y.S. Artamonov. Prediction of cluster system load using adaptive model mixture (in russian).
International Journal of Open Information Technologies, 5(5):9–15, 2017.
[AV15] Y. S. Artamonov and S. V. Vostokin. The use of cloud services templet web in conducting labora-
tory workshops on the supercomputer “sergey korolev”. In Proc. of X Int. Scientific and practical
conference Modern information technologies and IT education, MSU, Moscow, volume 2, pages
409–414, 2015.
[AV16] Y.S. Artamonov and S.V. Vostokin. Development of distributed applications for data collection
and analysis on the basis of a microservice architecture (in russian). Proceedings of the Samara
Scientific Center of the Russian Academy of Sciences, 18(4(4)):688–693, 2016.
[Col04] M. Cole. Bringing skeletons out of the closet: a pragmatic manifesto for skeletal parallel program-
ming. Parallel Computing, 30(3):389–406, 2004.
[GVL10] Horacio González-Vélez and Mario Leyton. A survey of algorithmic skeleton frameworks: high-level
structured parallel programming enablers. Software: Practice and Experience, 40(12):1135–1160,
2010.
[HKP11] J. Han, M. Kamber, and J. Pei. Data mining: concepts and techniques. Elsevier, 2011.
[Lam94] Leslie Lamport. The temporal logic of actions. ACM Trans. Program. Lang. Syst., 16(3):872–923,
May 1994.
[Lit14] V.G. Litvinov. Development and application of the computational model for skeleton solutions.
case study – using “bag-of-task” for hrbf neural network learning (in russian). J. Samara State
Tech. Univ., Ser. Phys. & Math. Sci., 3(36):183–195, 2014.
[MG11] P. Mell and T. Grance. The nist definition of cloud computing. Special publication 800-145.
National Institute of Standards and Technology: U.S. Department of Commerce, 2011.
[MWH98] S. Makridakis, S.C. Wheelwright, and R.J. Hyndman. Forecasting: Methods and Applications,
Third edition. John Wiley and Sons, 1998.
[SVP17] A.A. Stolbova, S.V. Vostokin, and S.N. Popov. Calculation of coefficients of wavelet transform
on cluster systems. In Proceedings of the international scientific conference Advanced information
technologies and scientific computing (PIT-2017), pages 476–478. Samara Scientific Center of RAS,
2017.
[VDA16] S.V. Vostokin, A.V. Doroshin, and Y.S. Artamonov. Application of the templet web system to
solve problems of mathematical modeling using high-performance systems (in russian). In Collected
Works of the XVIII All-Russian Seminar on Motion Control and Navigation of Aircraft: Part II.
Samara, 15-17 June 2015, pages 17–21. Samara Science Center of RAS, 2016.
134
[Vos16] S.V. Vostokin. Templet: a markup language for concurrent actor-oriented programming. In CEUR
Workshop Proceedings, volume 1638, pages 460–468, 2016.
[VT17] S.V. Vostokin and D.A. Tsarev. Skeletal software deployment technology to automate the calcula-
tions on a supercomputer sergey korolev. In Proceedings of the international scientific conference
Advanced information technologies and scientific computing (PIT-2017), pages 481–484. Samara
Scientific Center of RAS, 2017.
[War95] M. P. Ward. Language oriented programming. Software—Concepts and Tools, 15:147–161, 1995.
[WTWB+ 97] Sullivan Woodruff T., Dan Werthimer, Stuart Bowyer, Jeff Cobb, David Gedye, and David An-
derson. A new major seti project based on project serendip data and 100,000 personal computers.
International Astronomical Union Colloquium, 161:729–734, 1997.
[ZMK+ 17] Oleg Zaikin, Maxim Manzyuk, Stepan Kochemazov, Igor Bychkov, and Alexander Semenov.
A Volunteer-Computing-Based Grid Architecture Incorporating Idle Resources of Computational
Clusters, pages 769–776. Springer International Publishing, Cham, 2017.
135