Using Cognitive Computing for Learning Parallel Programming: An IBM Watson Solution

TL;DR

This paper presents a cognitive computing-based educational tool using IBM Watson to assist novice programmers in avoiding common OpenMP parallel programming mistakes, improving learning outcomes.

Contribution

It introduces a novel Watson-based dialogue system to support novice parallel programmers, enhancing their understanding and reducing errors in OpenMP programming.

Findings

Positive feedback from novice programmers on usefulness

Improved understanding of OpenMP directives

Potential reduction in programming errors

Abstract

While modern parallel computing systems provide high performance resources, utilizing them to the highest extent requires advanced programming expertise. Programming for parallel computing systems is much more difficult than programming for sequential systems. OpenMP is an extension of C++ programming language that enables to express parallelism using compiler directives. While OpenMP alleviates parallel programming by reducing the lines of code that the programmer needs to write, deciding how and when to use these compiler directives is up to the programmer. Novice programmers may make mistakes that may lead to performance degradation or unexpected program behavior. Cognitive computing has shown impressive results in various domains, such as health or marketing. In this paper, we describe the use of IBM Watson cognitive system for education of novice parallel programmers. Using the dialogue service of the IBM Watson we have developed a solution that assists the programmer in avoiding common OpenMP mistakes. To evaluate our approach we have conducted a survey with a number of novice parallel programmers at the Linnaeus University, and obtained encouraging results with respect to usefulness of our approach.

Tables

Table 1. Table 1 : Common OpenMP mistakes identified by Kolosov et al. [ 13 ] and Süß et al. [ 24 ] .

Performance errors	Reason
Unnecessary flush	If flush directive is used without parameters, it can reduce the performance of the program.
Using critical instead of atomic	The atomic directive is faster than critical. When atomic cannot be used, the compiler will not allow the programmer to use it.
Unnecessary protection from concurrent memory write	Local thread variables should not be protected from concurrent writing
Overwork in a critical region	It is known that critical regions reduce the performance of the program so using critical is generally not recommended.
Logical errors	Reason
Missing /openmp	If OpenMP is not enabled in the compiler settings, the OpenMP directives will be ignored
Missing parallel	If the programmer forgets to put the parallel keyword, the code will run sequentially
Missing omp	If omp keyword is forgotten the entire pragma will be ignored
Missing for	If the programmer want to divide a loop into $n$ threads and for is forgotten, the program will not split up the work into those n threads
Unnecessary parallelization	If the programmer puts the parallel keyword inside a parallel section, the loop will be run $n$ times
Incorrect usage of ordered	If the ordered directive is not correctly indicated, the compiler will decide to order randomly
Redefining the number of threads in a parallel section	Attempts to change the number of threads within a parallel region will result with run-time errors.
Lock a variable without initializing it	According to the specification, to lock a variable it first needs to be initialized
Unsetting locks from another thread	Locks set from one thread will cause unpredictable run-time behavior if unset from another thread
Parallel array without order	If the result depends on previous iterations, order clause is compulsory in order for it not to have unexpected behaviour.
Access to a share memory without protection	When several threads are modifying a variable the result is unpredictable.

Table 2. Table 2 : The questions of the conducted survey

#	Question
1	Do you think that such interactive assistance application can help you in parallel programming, more than search engines or paper-based resources?
2	Do you think that the answers you have received from our tool were accurate?
3	Do you find it useful that the application is multilingual?
4	Would you find it useful if the application could retrieve papers as an answer?

Table 3. Table 3 : matrix based representation of the survey results that shows the percentage of each question related to the answers of the participants

	1-star	2-stars	3-stars	4-stars	5-stars
Question 1	0%	0%	12.5%	37.5%	50%
Question 2	0%	12.5%	25%	25%	37.5%
Question 3	0%	12.5%	0%	12.5%	75%
Question 4	0%	25%	12.5%	25%	37.5%

Full text

0.1 Introduction

The modern parallel computing systems provide capabilities to solve complex computational and engineering problems [23] faster. Programming for parallel computing systems is much more complex than programming for sequential processors [22, 16], because it requires knowledge of the underlying parallel architecture and the programming models libraries (that are often device specific), and consideration of large amount of device specific configuration parameters (such as, numbers of cores, core speed, memory hierarchy level, cache, run-time system, etc) [21].

To alleviate the programmability challenges of parallel computing systems [12, 2, 25], various parallel programming models and languages [5] are proposed, including OpenMP, OpenACC, MPI, Pthreads, OpenCL, Cuda, and Intel TBB. While these approaches have helped to significantly reduce the programming effort, writing more complex code requires more effort, advanced knowledge of parallel algorithms and underlying architecture and is more prone to mistakes that may lead to incorrect program behavior or performance degradation [8]. To efficiently utilize the available resources on the modern parallel computing systems, programmers require adequate education [3].

OpenMP (Open Multi-Processing) is an Application Program Interface (API) that comprises a set of compiler directives, variables and library functions to program parallel computing systems. OpenMP is implemented as language extension of C, C++ and Fortran [4] for shared-memory parallel computing systems, and recent versions of OpenMP support also the heterogeneous computing systems. The main goal of OpenMP is to reduce the difficulty of writing parallel applications. It does that by using compiler directives, known as pragmas. However, it is up to the programmer to decide how and when to use these directives. Even though, the available documentation suggests that using OpenMP is simple and easy, Gonçalves et al. [8] show that using OpenMP is not as easy as it appears, and such suggestions may lead to code that provides incorrect results or poor performance [17, 18]. Furthermore, Kolosov et al. [13] and Süß et al. [24] has identified a number of commonly made OpenMP mistakes, and they have categorized them in logical and performance related errors.

Cognitive systems [15] are on the verge of becoming a milestone due to their ability to process natural language processing (NLP). This enables a whole new level of interaction between humans and computing systems, which may help people make better decisions. IBM Watson [6] is a cognitive system that uses the natural language to receive and answer questions. It is able to handle unstructured data, which composes 80% of the data available on the Web. IBM Watson learns a new subject by storing all the documents related to the topic on its own database, in which it later searches for the most suitable answer. Recently various solutions based on the IBM Watson have demonstrated impressive results [14]. For example, in 2011 the Watson Dialog service won at Jeopardy against two human former winners. Then, in 2012 Watson helped oncologists to extract valuable information to treat patients. Standard Bank is using Watson to solve customers’ queries. The American Cancer Society is using Watson to provide better answers to patients.

In this paper, we describe the use of cognitive computing to aid novice programmers learn parallel programming. We have developed an application based on the IBM Watson services that enables a dialog-based interaction with programmers during program development. Our solution is focused on helping novice programmers to avoid commonly made mistakes when they use OpenMP. We have implemented our solution to support interaction with the programmer in English and Spanish. Furthermore, we have conducted a survey to evaluate the usability of our solution. The results of the survey indicate that the developed application offers valuable answers that would be helpful for novice parallel programmers.

The key contributions of this paper are:

• •

A multi-language IBM Watson application that aids novice programmers to learn parallel programming with OpenMP,

• •

Evaluation of usability of our IBM Watson application.

The rest of the paper is organized as follows. In Section 0.2 we discuss the related work. Section 0.3 describes the methodology and implementation details. In Section 0.4 we first describe the context of the conducted survey, thereafter we discuss the results of the survey. We conclude our paper and provide future research directions in Section 0.5.

0.2 Related Work

Goel et al. [7] used different Watson services to develop six diverse applications that aim at understanding the functionality and capabilities of Watson and enhancing the human-computer co-creativity. By developing these diverse applications the authors argue that Watson has potential to be used in different domains, and has large range of opportunities to be used as an educational tool.

Witte et al. [26] uses natural language processing to bring new levels of support to software developers. A plug-in that is integrated in the Eclipse IDE is developed, which provides quality analysis of the comment found in source code and version control commits. The aim of this project is to help software developers reduce the effort required to analyze their code by extracting useful information that might be valuable to understand the functionality of the application that is not always obvious by looking at the source code only.

An interactive tool for parallelization of OpenMP sequential programs is proposed by Ishihara et al. [11]. This tool provide four types of assistance to the developers, including analysis of the parallelism, identification of candidate parallel sections, enhancing the parallelism through code restructuring, and analysis of the execution time.

Harms [9] proposes an approach that is able to monitor and understand the programming skill level of the developer and adaptively suggest code examples that may help to learn new programming concepts found within the suggested examples. The author argues that this approach avoid overwhelming the memory of novice programmers by considering the previous knowledge of the programmer and carefully suggesting examples that contain new information.

Sah and Vaidya [20] review, discuss characteristics and classify existing parallelization tools based on: (1) the time the tools were developed (before or after the multicore era); (2) their contribution during the parallelization process, and (3) the ability to provide assistance for parallel programming. Furthermore, they propose their parallel programming tool that assist developers during the software development time.

In contrast to the related work, we use cognitive computing to assist programmers in avoiding common logical and performance mistakes. Our solution is based on the IBM Watson dialogue service and focuses on OpenMP.

0.3 Our methodology

In this section first we will describe the design of our approach thereafter we will provide some implementation details.

0.3.1 Design

Our application is based on the IBM Watson Dialog service to provide communication means between the user and the system through natural language processing with the aim to avoid common OpenMP mistakes. The architecture overview of our application is depicted in Figure 1. The users interact with our application using an interface, which allows them to write questions in text form. The user that will presumably be a parallel programmer will use the interface to ask a question related to parallel programming. Please note that as is usual in natural language, the question can be formulated in several ways. For accessibility, the interface may be enhanced with voice recognition or connected to some kind of integrated development environment.

The interface sends the user input to our application, which is connected to the Watson Dialog Service. The dialog service analyzes the questions and gathers information that it needs to provide the most suitable answer for the user. To extend the functionality of our application, one can connect the application to additional services such as speech-to-text services.

The application is connected to a back-end system that is responsible to display the answer of the question to the user. At this point, the application has the answer for the user. There are two scenarios, (1) the question has been understood and application provides a proper answer to the user, and (2) the question has not been understood and a default message saying “I am sorry, I did not understand your question. Please try another question.”is provided to the user.

The overview of the IBM Watson dialog service is illustrated in Figure 2. The dialog service provides means for communication between computers and the users in a question-and-answer fashion through natural language. To use this service, first the training data should be gathered and prepared by an expert. As our aim is to provide a tool that aids novice parallel programmers write parallel code using OpenMP, we considered to use as training data the common OpenMP mistakes identified by Kolosov et al. [13] and Süß et al. [24]. By the time of writing this paper, there are 32 commonly identified mistakes 111The list of all 32 identified OpenMP mistakes can be found in: https://software.intel.com/en-us/articles/32-openmp-traps-for-c-developers, however due to space limitations we have listed only some of them in Table 1.

The gathered data should be translated into dialog models that is part of the dialog flow design process. For instance, the common OpenMP mistake where programmers redefine the number of threads within a parallel loop, will be translated in a dialog fashion where the input would be like: Can I change a variable inside a pragma omp loop?. Figure 3 depicts the interaction with the programmer in English and Spanish.

The push live to users enables the connection of the dialog service with the user interface, and monitoring the conversations. The last component enables dynamic learning from real interactions by adjusting the existing content and adding new one based on the user activity.

0.3.2 Implementation Details

In order to build an application that uses IBM Watson Dialog service the developer needs to specify the mandatory settings for the service as shown in the Listing 1. For example, the AUTOLEARN (see line 4) setting allows the dialog to suggest another node when the input does not match. The LANGUAGE (see line 3) setting allows the user to determine the account language. Please note that we show only an excerpt of all possible settings, for the full list of available setting we refer the reader to the Watson Dialog Service documentation [10].

The main characteristic of the Dialog service is the dialog tag, which has a mandatory child named flow that is responsible for the content of the dialog because it includes the main libraries (see Listing 2). The flow tag may have a child named folder that is used to allocate, organize and maintain the information in the dialog. There are four types of folders, Main, Library, Global, and Concepts.

The Main folder stores the welcome messages, whereas the Library folder stores the core of the dialog such as, the input (an example of the input node is shown in Listing 3), output, structures, and other valuable information. Each question is represented as an input node of the dialog service, where each node has a child grammar node, and the grammar node must have at least one child item node (see Listing 3). As the dialog service is based on natural language, each question may have multiple variations. We can configure these variations by adding multiple items inside the grammar. The first item represents the primary variation of the question. We can have multiple variations by using the wildcards \$$ (dollar sign) and *$ (asterisk). When the dollar sign is used the question becomes more open as the user can type down the question in multiple ways, however the question must be followed by the first verb after the dollar sign (see Line 4 Listing 3). The questions could be: “Is it possible to change a variable inside a loop?”, or “May I to change a variable inside a loop?”. When the asterisk is in use it means that the place corresponding to the asterisk can be changed for another suitable word (see Line 5 Listing 3), for example: “Can I change the number of threads …?”, or “Is it possible to change all of the threads …?”.

The output tag is a child of the input and is used to store the answers of the corresponding question.For example, the corresponding answer to the question variations represented in the input node in Listing 3 would be “It is explicitly forbidden to change the variable from inside the loop.”, and the corresponding xml node is shown in Listing 4

If the system does not understand the question or it does not have a proper answer, the system will display a default message that could be customized using the default node (see Listing 5).

Please note that from September 2016 IBM has retired the Dialog service, which disallows creation of new instances of this service. However, existing instances will continue to work until August 2017. An equivalent service, so called Conversation service has been introduced, and developers are encouraged to migrate their Dialog service based applications to the Conversation service.

0.4 Evaluation

To evaluate the usefulness of our approach we have conducted an anonymous survey within the Linnaeus University campus. The target group that we have surveyed includes bachelor students from the department of computer science that have little knowledge in parallel programming. In total, eight novice parallel programmers have accepted to take part on the survey. The process of selection of candidates, data collection and analysis, and reporting is adapted from the guidelines presented by Runeson and Höst [19].

The aim of this survey is to investigate whether such interactive tools would help novice programmers solve parallel programming problems as well as identify ways to improve our tool. To keep the survey simple, and to avoid survey fatigue of our respondents, which usually happens because surveys are too long and include non-relevant questions, we have defined a survey with only four questions. Table 2 lists the questions of our survey.

To measure the performance quality of our tool we have used the Likert [1] scale system to allow respondents to rank the quality of our tool, where participants could choose answers between one and 5 stars, where One star stands for Strongly disagree, Two stars stands for Somewhat disagree, Three stars means Neither agree nor disagree, Four stars means Somewhat agree, and Five stars stands for Strongly agree.

The results of the survey are depicted in Figure 4. The x-axis indicates the stars, whereas the y-axis indicates the collected points such that if question 4 received 3 points for 5 stars it means that 3 participants strongly agreed that it would be useful to enhance our tool with the ability to retrieve papers as an answer. We may observe that most of the questions received more than three stars. For instance, when asked whether our tool is more helpful than using search engines or paper-based resources, 3 participants neither agreed nor disagreed, three other participants agreed to some extent, and four of them strongly agreed. When asked whether the answers retrieved from our tool were accurate, one of the participants disagreed to some extent, two participant were neutral, two participants agreed to some extent, and three of them strongly agreed. Six of the participants strongly agreed, one agreed to some extent and another one disagreed to some extent that our tool is useful because it can respond to questions asked in different languages. Two participants disagreed to some extent and two others agreed to some extent, another one was neutral, and three others strongly agreed that enhancing our tool with the ability to retrieve paper as an answer would be useful.

Table 3 shows a matrix based representation of the percentage of each question related to the respondents’ answers. The results show that the application would be successful among students as they would like to have an application that can help them in parallel programming by using natural language. In the first question 87.5% of the total score corresponds to 4 stars or more, which means that the respondents highly agree with the usefulness of the application. In the second question 62.5% of the total score corresponds to 4 stars or more, which means that the respondents highly agree with the usefulness of the application. In the third question 87.5% of the total participants appreciated having multi-language support in this application. In the last question, 62.5% of the users think that enhancing our tool with the ability to retrieve papers as answers is useful.

0.5 Conclusion and Future Work

Cognitive systems, like IBM Watson, are able to learn trough user’s input and be taught by experts. An application that uses this technology can become a milestone in the field in which it is being used due to the fact that a community can be created to improve applications, share new ideas and discover features that no one has thought of before. The usefulness of such systems has been demonstrated in various fields, such as in health care, where doctors can treat their patients better owing to previous experiences with common diseases.

In this paper we have investigated the use of cognitive computing to help programmers learn parallel programming. We have used the IBM Watson dialog service to enable the interaction between the user and the system in a dialog-fashion way using natural language. Our application is trained to respond to questions related to common mistakes that novice programmers do when using OpenMP, which helps them avoid such mistakes, write code that produces the correct result and runs faster. Furthermore, such systems may reduce the time investment required to learn parallel programming. Since Watson can learn from the user’s collected input, the application can be improved as it is used. The proposed tool can answer questions that a user may ask, but it will neither generate code nor find code errors.

To evaluate the usefulness of our application, we conducted a survey with a number of novice parallel programmers. The results of the survey show that novice parallel programmers are willing to use such interactive application while writing their parallel programs and would find it useful to improve their knowledge of the subject. Furthermore, the results show that retrieving papers as answers will significantly attract users to use our application. We believe that our tool can be used as an educational resource in a beginners course in parallel programming.

Future research will address the extension of our solution with additional IBM Watson services that enable automatic input of data from existing sources of parallel programming knowledge.