{"id":1843,"date":"2019-12-22T11:47:08","date_gmt":"2019-12-22T06:17:08","guid":{"rendered":"https:\/\/www.rangakrish.com\/?p=1843"},"modified":"2019-12-22T11:47:08","modified_gmt":"2019-12-22T06:17:08","slug":"distributed-computing-with-linda","status":"publish","type":"post","link":"https:\/\/www.rangakrish.com\/index.php\/2019\/12\/22\/distributed-computing-with-linda\/","title":{"rendered":"Distributed Computing with Linda"},"content":{"rendered":"

Linda<\/strong><\/em><\/a>, originally proposed by Nicholas Carriero and David Gelernter, is a model of process communication using a small set of well-defined primitives, operating on a tuple space<\/strong><\/em><\/a>.\u00a0<\/span><\/p>\n

Interestingly, Sicstus Prolog<\/strong><\/em><\/a>\u00a0comes with a library that implements Linda<\/strong><\/em> (both Server<\/strong><\/em> and Client<\/strong><\/em>).\u00a0 I played with it a little bit and really enjoyed it.\u00a0<\/span>In this article, I would like share my experience.\u00a0<\/span><\/p>\n

The Linda server<\/strong><\/em> process acts like a tuple space<\/strong><\/em> or blackboard<\/strong><\/em> on which one or more client<\/strong><\/em> processes can read<\/strong><\/em> and write<\/strong><\/em>. Here are the operations that the client processes can perform:<\/p>\n

out(X)<\/strong> => Write the tuple X to the tuple space<\/p>\n

in(X)<\/strong> => Read and remove the tuple X from the tuple space<\/p>\n

rd(X)<\/strong> => Read, but not remove, the tuple X from the tuple space<\/p><\/blockquote>\n

While out<\/i><\/b> always succeeds, both in<\/i><\/b> and rd <\/i><\/b>will block until the required tuple becomes available.<\/p>\n

Two other predicates, in_noblock(X)<\/i><\/b> and rd_noblock(X)<\/i><\/b> will return with failure if the tuple is not available in the tuple space.<\/p>\n

The original Linda system had one more operation called eval<\/strong><\/em>, but that is not supported in Sicstus Prolog<\/strong><\/em>\u2019s implementation.<\/p>\n

By the way, a tuple<\/strong><\/em> is similar to a struct<\/strong><\/em> or record<\/strong><\/em>\u00a0found in many programming languages, and can have any number of fields.<\/p>\n

The overall process communication is shown in the following diagram:<\/p>\n

\"Linda<\/a>
Linda System Overview<\/strong><\/figcaption><\/figure>\n

As you can see, processes (client processes in the diagram) do not communicate among themselves directly. A process posts one or more tuples<\/strong><\/em> on the tuple space<\/strong><\/em> and other processes respond to that by posting other tuples<\/strong><\/em>. This is a loosely-coupled model.\u00a0<\/span><\/p>\n

In the example I am going to discuss, we have the following processes:<\/p>\n

Server process<\/strong> => This acts as the tuple space or blackboard<\/p>\n

Text Parser Process<\/strong> => This is a client process that parses simple English sentences and returns the corresponding parse tree<\/p>\n

Math Process<\/strong> => Another trivial client process that can perform Sum, Product and Square root on numbers.<\/p>\n

Simple Client<\/strong> => This client process makes use of the Parser and Math processes<\/p><\/blockquote>\n

Although technically the different processes could all be run on different computers (Windows<\/strong><\/em> machines in my case), I chose to run them on the same desktop computer for the sake of convenience.<\/p>\n

Let me start the Linda server<\/strong><\/em> process first. This serves as the tuple space<\/i><\/b>. I use the address printed by the server process to start the remaining three client processes. You can see that the server echoes the connection established with the clients.<\/p>\n

\"The<\/a>
The Tuple Space Server<\/strong><\/figcaption><\/figure>\n

Here is an image showing the Parser<\/strong><\/em> and Math<\/strong><\/em> servers after the launch:<\/p>\n

\"Math<\/a>
Math and Parser Servers<\/strong><\/figcaption><\/figure>\n

Finally, let us start the simple client that allows us to communicate with the servers:<\/p>\n

\"Simple<\/a>
Simple Client<\/strong><\/figcaption><\/figure>\n

We will use the Simple client<\/strong> <\/em>console to perform some parsing and math tasks. The parser process uses my iLexicon<\/i><\/b> library and implements a simple DCG<\/strong><\/em>-based parser for a subset of English. Given a word, it can return its parts-of-speech (POS) and also check whether a given <word, pos><\/strong><\/em> is valid. See this image.<\/p>\n

\"Basic<\/a>
Basic Parsing and POS Operations<\/strong><\/figcaption><\/figure>\n

In the above, the client asks for the POS of the word anger<\/i><\/b>. The parser server responds with the relevant POS, in this case, it is both noun<\/i><\/b> and verb<\/i><\/b>. Please note that the client process posts this request on the blackboard (tuple space) and is not directly communicating with the parser server (when you see the source code you will understand how). As explained earlier, every interaction between processes is entirely through the tuple space.<\/p>\n

The third command in the client process asks for the parse tree<\/i><\/b> of the sentence “cats are friendly\u201d<\/strong><\/em>. Once again, the parser server responds by parsing the given sentence and sending back the parse tree. Here is the parse tree for this sentence:<\/p>\n

\"Parse<\/a>
Parse Tree – 1<\/strong><\/figcaption><\/figure>\n

The above parse tree is based on the DCG<\/strong><\/em> rules I have implemented in the parser. There is nothing sacred about it.<\/p>\n

Next, let us try to parse a slightly longer sentence:<\/p>\n

\"Parsing<\/a>
Parsing Another Sentence<\/strong><\/figcaption><\/figure>\n

Here is the corresponding parse tree.<\/p>\n

\"Parse<\/a>
Parse Tree – 2<\/strong><\/figcaption><\/figure>\n

OK, time to switch to the Math<\/strong><\/em> processor. To make things slightly more interesting, let us start one more math processor and pose some math-related queries on the client.<\/p>\n

\"Posing<\/a>
Posing Math Queries<\/strong><\/figcaption><\/figure>\n

You can see that the math operations are promptly responded to by one of the math processes. Here is the image showing the three processes in action.\u00a0<\/span><\/p>\n

\"Parser<\/a>
One Parser and Two Math Servers<\/strong><\/figcaption><\/figure>\n

Both the math processes are polling the tuple space<\/i><\/b> for tuples that they can handle and when a matching tuple is posted by the client process, one of them non-deterministically grabs it, processes it and posts the reply back to the tuple space<\/i><\/b>. This is then picked up by the client, which is waiting<\/strong><\/em> for the result.<\/p>\n

Nice, isn\u2019t it? We can thus add processes dynamically<\/strong><\/em> to scale up, or remove processes to scale down, but the client is completely unaware of this. That is the benefit of loose coupling.<\/p>\n

I am sure you are curious to look at the source. Let me not disappoint you. Here is the source for launching the tuple space<\/i><\/b> server:<\/p>\n

\"Blackboard<\/a>
Blackboard Server<\/strong><\/figcaption><\/figure>\n

Here is the parser server source:<\/p>\n

\"Parser<\/a>
Parser Server Source<\/strong><\/figcaption><\/figure>\n

The above does not include the code for the DCG<\/strong> and iLexicon<\/i><\/b> functionality.<\/p>\n

The first part of the math<\/strong><\/em> server source given below shows the main predicates that interact with the tuple space.<\/p>\n

\"Math<\/a>
Math Server (Part 1)<\/strong><\/figcaption><\/figure>\n

The actual computation of the math operations is shown below. No magic here.<\/p>\n

\"Math<\/a>
Math Server (Part 2)<\/strong><\/figcaption><\/figure>\n

Finally, here is how the client process looks like:<\/p>\n

\"The<\/a>
The Simple Client<\/strong><\/figcaption><\/figure>\n

That is it. Hope I managed to convey the basic idea of the Linda<\/strong><\/em> system. As mentioned in the beginning, I have implemented this example in Sicstus Prolog<\/strong><\/em> on windows.<\/p>\n

Have a Merry Christmas<\/strong><\/em> and a wonderful holiday season! See you again in the New Year!<\/p>\n","protected":false},"excerpt":{"rendered":"

Linda, originally proposed by Nicholas Carriero and David Gelernter, is a model of process communication using a small set of well-defined primitives, operating on a tuple space.\u00a0 Interestingly, Sicstus Prolog\u00a0comes with a library that implements Linda (both Server and Client).\u00a0 I played with it a little bit and really enjoyed it.\u00a0In this article, I would […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"advanced_seo_description":"","jetpack_seo_html_title":"","jetpack_seo_noindex":false,"jetpack_post_was_ever_published":false,"_jetpack_newsletter_access":"","_jetpack_dont_email_post_to_subs":false,"_jetpack_newsletter_tier_id":0,"_jetpack_memberships_contains_paywalled_content":false,"_jetpack_memberships_contains_paid_content":false,"footnotes":"","jetpack_publicize_message":"","jetpack_publicize_feature_enabled":true,"jetpack_social_post_already_shared":true,"jetpack_social_options":{"image_generator_settings":{"template":"highway","default_image_id":0,"font":"","enabled":false},"version":2}},"categories":[17,147],"tags":[223,222,148],"class_list":["post-1843","post","type-post","status-publish","format-standard","hentry","category-programming","category-prolog","tag-distributed-computing","tag-linda-tuple-space","tag-prolog"],"jetpack_publicize_connections":[],"jetpack_featured_media_url":"","jetpack_sharing_enabled":true,"jetpack_shortlink":"https:\/\/wp.me\/p9OLnF-tJ","jetpack-related-posts":[{"id":1770,"url":"https:\/\/www.rangakrish.com\/index.php\/2019\/11\/10\/calling-c-methods-from-sicstus-prolog-through-com-interface\/","url_meta":{"origin":1843,"position":0},"title":"Calling C# Methods from Sicstus Prolog through COM Interface","author":"admin","date":"November 10, 2019","format":false,"excerpt":"Recently\u00a0I needed to make use of a C# library (which I had implemented a few years ago) from Sicstus Prolog. Calling C\/C++ functions from Sicstus Prolog is fairly well documented. When it comes to C#\/.NET, the official documentation recommends the PrologBeans library. After going through the documentation, I felt that\u2026","rel":"","context":"In "Programming"","block_context":{"text":"Programming","link":"https:\/\/www.rangakrish.com\/index.php\/category\/programming\/"},"img":{"alt_text":"Prolog Client Code","src":"https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2019\/11\/Prolog-Code.jpg?resize=350%2C200&ssl=1","width":350,"height":200,"srcset":"https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2019\/11\/Prolog-Code.jpg?resize=350%2C200&ssl=1 1x, https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2019\/11\/Prolog-Code.jpg?resize=525%2C300&ssl=1 1.5x"},"classes":[]},{"id":2366,"url":"https:\/\/www.rangakrish.com\/index.php\/2021\/03\/28\/implementing-ilexicon-using-litedb\/","url_meta":{"origin":1843,"position":1},"title":"Implementing iLexicon using LiteDB","author":"admin","date":"March 28, 2021","format":false,"excerpt":"iLexicon is an \"intelligent\" dictionary that can be used to build Natural Language applications. I have two implementations, one in Lisp and another in Prolog. Both implementations are memory-based, in order to speed up performance. I have written several articles referencing it, for example see this. \u00a0 LiteDB is a\u2026","rel":"","context":"In "Natural Language Processing"","block_context":{"text":"Natural Language Processing","link":"https:\/\/www.rangakrish.com\/index.php\/category\/natural-language-processing\/"},"img":{"alt_text":"Sample Commands","src":"https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2021\/03\/Session1.jpg?resize=350%2C200&ssl=1","width":350,"height":200},"classes":[]},{"id":912,"url":"https:\/\/www.rangakrish.com\/index.php\/2018\/04\/22\/question-answering-using-dependency-trees\/","url_meta":{"origin":1843,"position":2},"title":"Question Answering\u00a0Using Dependency Trees","author":"admin","date":"April 22, 2018","format":false,"excerpt":"A few weeks ago I had written about my brief experiment with Mathematica's new feature, which provides answers to questions based on given text. After that post, I spent some time thinking about how to implement something similar. In today's post, I want to show you what I have been\u2026","rel":"","context":"In "LISP"","block_context":{"text":"LISP","link":"https:\/\/www.rangakrish.com\/index.php\/category\/lisp\/"},"img":{"alt_text":"Dependency Tree","src":"https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2018\/04\/Deptree-example.png?resize=350%2C200","width":350,"height":200},"classes":[]},{"id":2433,"url":"https:\/\/www.rangakrish.com\/index.php\/2021\/06\/06\/getting-to-know-visual-prolog-10\/","url_meta":{"origin":1843,"position":3},"title":"Getting to Know Visual Prolog 10","author":"admin","date":"June 6, 2021","format":false,"excerpt":"Visual Prolog\u00a0has its roots in Turbo Prolog, which was popularized by Borland in the mid 1980s. It is developed and supported by PDC A\/S, Denmark. So how is Visual Prolog different from other Prolog implementations out there, for example, SWI-Prolog or Sicstus Prolog? Here are the key differences: 1) It\u2026","rel":"","context":"In "C++"","block_context":{"text":"C++","link":"https:\/\/www.rangakrish.com\/index.php\/category\/c\/"},"img":{"alt_text":"Visual Prolog Project","src":"https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2021\/06\/Project-300x183.jpg?resize=350%2C200&ssl=1","width":350,"height":200,"srcset":"https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2021\/06\/Project-300x183.jpg?resize=350%2C200&ssl=1 1x, https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2021\/06\/Project-300x183.jpg?resize=525%2C300&ssl=1 1.5x"},"classes":[]},{"id":1078,"url":"https:\/\/www.rangakrish.com\/index.php\/2018\/09\/30\/dependency-graph-to-rdf-part-2\/","url_meta":{"origin":1843,"position":4},"title":"Dependency Graph to RDF – Part 2","author":"admin","date":"September 30, 2018","format":false,"excerpt":"In the last post, I outlined an approach to convert a dependency graph (the result of dependency parsing) to RDF. The particular RDF format I used is Turtle, which is widely supported. Today, I would like to show how to load this RDF data in a Semantic\u00a0 Graph database and\u2026","rel":"","context":"In "LISP"","block_context":{"text":"LISP","link":"https:\/\/www.rangakrish.com\/index.php\/category\/lisp\/"},"img":{"alt_text":"Browser View","src":"https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2018\/09\/Checking-the-server.png?resize=350%2C200&ssl=1","width":350,"height":200,"srcset":"https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2018\/09\/Checking-the-server.png?resize=350%2C200&ssl=1 1x, https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2018\/09\/Checking-the-server.png?resize=525%2C300&ssl=1 1.5x, https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2018\/09\/Checking-the-server.png?resize=700%2C400&ssl=1 2x"},"classes":[]},{"id":3260,"url":"https:\/\/www.rangakrish.com\/index.php\/2023\/11\/26\/generating-polynomials-in-prolog\/","url_meta":{"origin":1843,"position":5},"title":"Generating Polynomials in Prolog","author":"admin","date":"November 26, 2023","format":false,"excerpt":"Polynomial is an important topic in High School maths curriculum. There are many online courses that explain the topic in great details with lots of examples and sample exercises. Wouldn\u2019t it be interesting if we can generate polynomials of given degree programmatically? It turns out that this is not such\u2026","rel":"","context":"In "Programming"","block_context":{"text":"Programming","link":"https:\/\/www.rangakrish.com\/index.php\/category\/programming\/"},"img":{"alt_text":"Generating Polynomials - Main Clauses","src":"https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2023\/11\/Code1-300x163.jpg?resize=350%2C200&ssl=1","width":350,"height":200,"srcset":"https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2023\/11\/Code1-300x163.jpg?resize=350%2C200&ssl=1 1x, https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2023\/11\/Code1-300x163.jpg?resize=525%2C300&ssl=1 1.5x"},"classes":[]}],"_links":{"self":[{"href":"https:\/\/www.rangakrish.com\/index.php\/wp-json\/wp\/v2\/posts\/1843","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.rangakrish.com\/index.php\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.rangakrish.com\/index.php\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.rangakrish.com\/index.php\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.rangakrish.com\/index.php\/wp-json\/wp\/v2\/comments?post=1843"}],"version-history":[{"count":0,"href":"https:\/\/www.rangakrish.com\/index.php\/wp-json\/wp\/v2\/posts\/1843\/revisions"}],"wp:attachment":[{"href":"https:\/\/www.rangakrish.com\/index.php\/wp-json\/wp\/v2\/media?parent=1843"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.rangakrish.com\/index.php\/wp-json\/wp\/v2\/categories?post=1843"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.rangakrish.com\/index.php\/wp-json\/wp\/v2\/tags?post=1843"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}