{"id":3017,"date":"2023-02-16T15:16:20","date_gmt":"2023-02-16T09:46:20","guid":{"rendered":"https:\/\/www.rangakrish.com\/?p=3017"},"modified":"2023-02-16T15:16:20","modified_gmt":"2023-02-16T09:46:20","slug":"calling-external-dll-functions-from-julia","status":"publish","type":"post","link":"https:\/\/www.rangakrish.com\/index.php\/2023\/02\/16\/calling-external-dll-functions-from-julia\/","title":{"rendered":"Calling External DLL Functions from Julia"},"content":{"rendered":"

Julia<\/strong><\/em><\/a> supports calling external functions, especially those written in \u201cC\u201d<\/strong><\/em> language. As Julia<\/strong> documentation<\/strong><\/a><\/em> says, such calls do not involve any \u201cboilerplate\u201d<\/strong><\/em> code and hence are efficient. In today\u2019s article, I am going to show how to call functions defined in a DLL<\/strong><\/em> (Windows 64 bit). Instead of using direct \u201cC\u201d<\/strong><\/em> functions, I will discuss how to compile LispWorks<\/strong><\/em><\/a> Lisp<\/strong><\/em> code into a DLL<\/strong><\/em> and then interface it with Julia<\/strong><\/em>.<\/p>\n

My environment:<\/strong><\/span><\/p>\n

1) Windows 10 (64 bit)
\n2) LispWorks Enterprise Edition 8.0.1 (64 bit, for Windows)<\/p>\n

Let us start with the Lisp<\/strong><\/em> code first. I have written a function \u201clispEval\u201d<\/strong><\/em> that takes a string, evaluates it as a sequence of S-Expressions<\/strong><\/em> and returns the result as a string. It uses LispWorks<\/strong> \u201cFLI\u201d<\/strong><\/em> package. Here is the code:<\/p>\n

\"The<\/a>
The “lispEval” Function<\/strong><\/figcaption><\/figure>\n

To make the Julia<\/strong><\/em> interaction more interesting, I have defined another Lisp<\/strong><\/em> function \u201cjuliaCallBack\u201d<\/strong><\/em>, which takes a \u201cpointer\u201d<\/strong><\/em> to a Julia<\/strong><\/em> function and then calls it with two integer arguments. The Julia<\/strong><\/em> function is expected to return an integer, which is then returned as it is from the Lisp<\/strong><\/em> function. Nothing fancy here, except that this allows 2-way communication between Lisp<\/strong><\/em> and Julia<\/strong><\/em>. Here is the second function:<\/p>\n

\"The<\/a>
The “juliaCallBack” Function<\/strong><\/figcaption><\/figure>\n

Both the functions are exported from the Lisp<\/strong><\/em> code.<\/p>\n

\"Exporting<\/a>
Exporting the Functions from Lisp DLL<\/strong><\/figcaption><\/figure>\n

Now, to compile this Lisp<\/strong><\/em> code and generate the DLL<\/strong><\/em>, we execute the following command on Windows prompt:<\/p>\n

CMD>”G:\\Program Files\\LispWorks8\\lispworks-8-0-0-x64-windows.exe” -build lisp-call.lisp<\/strong><\/em><\/p>\n

This completes the DLL<\/strong><\/em> creation. Next, we copy the DLL<\/strong><\/em> to the Julia<\/strong><\/em> project directory so that it is accessible from our Julia<\/strong><\/em> environment.<\/p>\n

I have already installed Julia 1.8.5<\/strong><\/em> on my Windows machine. It includes \u201cIJulia\u201d<\/strong><\/em> package that allows me to work conveniently with JupyterLab<\/strong><\/em> IDE. Here is how I launch it:<\/p>\n

\"Launching<\/a>
Launching JupyterLab IDE<\/strong><\/figcaption><\/figure>\n

The notebook interface provides an interactive session with Julia<\/strong><\/em>. First we need to open the Lisp DLL<\/strong><\/em> and bind a variable to the \u201clispEval\u201d<\/strong><\/em> function in the DLL<\/strong><\/em>. The Julia<\/strong><\/em> function by the same name, defined in cell [5]<\/strong><\/em>, acts as a wrapper by allocating the required buffer and passing it to Lisp.<\/p>\n

\"Calling<\/a>
Calling the Lisp Function\u00a0<\/strong><\/figcaption><\/figure>\n

Cells [6] <\/strong><\/em>and [7]<\/strong><\/em> show that when the DLL<\/strong><\/em> function \u201clispEval\u201d<\/strong><\/em> is called with a string representing an S-Expression, we get the corresponding answer as a string.<\/p>\n

The second example shows the other Lisp<\/strong><\/em> function \u201cjuliaCallBack\u201d<\/strong><\/em> in action.<\/p>\n

\"Testing<\/a>
Testing the “juliaCallBack” Function<\/strong><\/figcaption><\/figure>\n

As before, we need to bind the DLL<\/strong><\/em> function to a Julia<\/strong><\/em> variable. Then we define a Julia<\/strong><\/em> function \u201cfooBar\u201d<\/strong><\/em> whose pointer will be passed to the Lisp<\/strong><\/em> function. We need to use the “@cfunction”<\/strong><\/em> macro to generate a c-callable function pointer from a Julia<\/strong><\/em> function. The \u201ctestCallBack\u201d<\/strong> <\/em>function is a simple wrapper around the underlying \u201cccall\u201d<\/strong><\/em>. Cells [12] <\/strong><\/em>and [13]<\/strong><\/em> show that the call works correctly.<\/p>\n

Just to make sure that the Lisp<\/strong><\/em> call back is general enough, let us define another Julia<\/strong><\/em> function \u201cfindMax\u201d<\/strong><\/em>, whose pointer will be passed to the Lisp<\/strong><\/em> function.<\/p>\n

\"Another<\/a>
Another Callback Function<\/strong><\/figcaption><\/figure>\n

The cells [16] <\/strong><\/em>and [17]<\/strong><\/em> show that this also works as expected.<\/p>\n

As the above examples demonstrate, calling external functions available in shared libraries is straightforward. You can download the Lisp<\/strong><\/em> code from here<\/strong><\/em><\/a>. The “Jupyterlab”<\/strong><\/em> notebook is available here<\/strong><\/em><\/a>.<\/p>\n

Have a nice day and a great weekend!<\/p>\n","protected":false},"excerpt":{"rendered":"

Julia supports calling external functions, especially those written in \u201cC\u201d language. As Julia documentation says, such calls do not involve any \u201cboilerplate\u201d code and hence are efficient. In today\u2019s article, I am going to show how to call functions defined in a DLL (Windows 64 bit). Instead of using direct \u201cC\u201d functions, I will discuss […]<\/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_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},"jetpack_post_was_ever_published":false},"categories":[63,18,17],"tags":[149,64,352,268],"class_list":["post-3017","post","type-post","status-publish","format-standard","hentry","category-julia","category-lisp","category-programming","tag-dll","tag-julia","tag-jupyterlab","tag-lispworks-lisp"],"jetpack_publicize_connections":[],"jetpack_featured_media_url":"","jetpack_sharing_enabled":true,"jetpack_shortlink":"https:\/\/wp.me\/p9OLnF-MF","jetpack-related-posts":[{"id":944,"url":"https:\/\/www.rangakrish.com\/index.php\/2018\/06\/10\/calling-lisp-functions-from-go-language\/","url_meta":{"origin":3017,"position":0},"title":"Calling Lisp Functions from Go Language","author":"admin","date":"June 10, 2018","format":false,"excerpt":"In the previous post, we saw how to invoke a Go function from Lisp. In today's post, I would like to explain how to go in the other direction, namely, how to call Lisp functins from Go. There are two ways to do this. The first approach is to load\u2026","rel":"","context":"In "Golang"","block_context":{"text":"Golang","link":"https:\/\/www.rangakrish.com\/index.php\/category\/golang\/"},"img":{"alt_text":"Direct DLL Call","src":"https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2018\/06\/LispCall.png?resize=350%2C200","width":350,"height":200,"srcset":"https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2018\/06\/LispCall.png?resize=350%2C200 1x, https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2018\/06\/LispCall.png?resize=525%2C300 1.5x"},"classes":[]},{"id":2057,"url":"https:\/\/www.rangakrish.com\/index.php\/2020\/07\/19\/calling-lisp-functions-from-elixir\/","url_meta":{"origin":3017,"position":1},"title":"Calling Lisp Functions from Elixir","author":"admin","date":"July 19, 2020","format":false,"excerpt":"In the last article\u00a0I showed how we can simulate the idea of Lisp's \"closure\" in Elixir. Today, I would like to demonstrate how we can call Lisp functions from Elixir using the NIF interface. What is the need to integrate Elixir with another language? I can think of two reasons:\u2026","rel":"","context":"In "Elixir"","block_context":{"text":"Elixir","link":"https:\/\/www.rangakrish.com\/index.php\/category\/elixir\/"},"img":{"alt_text":"Using the Lisp Functions","src":"https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2020\/07\/Session.jpg?resize=350%2C200&ssl=1","width":350,"height":200,"srcset":"https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2020\/07\/Session.jpg?resize=350%2C200&ssl=1 1x, https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2020\/07\/Session.jpg?resize=525%2C300&ssl=1 1.5x, https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2020\/07\/Session.jpg?resize=700%2C400&ssl=1 2x"},"classes":[]},{"id":963,"url":"https:\/\/www.rangakrish.com\/index.php\/2018\/06\/24\/calling-go-functions-from-lisp-part-2\/","url_meta":{"origin":3017,"position":2},"title":"Calling Go Functions from Lisp – Part 2","author":"admin","date":"June 24, 2018","format":false,"excerpt":"In my earlier article Calling Go Functions from Lisp, I explained the steps for making calls to Go functions from another language, specifically LispWorks Lisp. Today, I want to give a slightly more\u00a0 interesting example showing the use of Go channels\u00a0through exported functions. Go is widely admired for its native\u2026","rel":"","context":"In "Golang"","block_context":{"text":"Golang","link":"https:\/\/www.rangakrish.com\/index.php\/category\/golang\/"},"img":{"alt_text":"Go Functions","src":"https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2018\/06\/Go-Functions.png?resize=350%2C200","width":350,"height":200},"classes":[]},{"id":2645,"url":"https:\/\/www.rangakrish.com\/index.php\/2021\/12\/25\/calling-lisp-functions-from-d-language\/","url_meta":{"origin":3017,"position":3},"title":"Calling Lisp Functions from D Language","author":"admin","date":"December 25, 2021","format":false,"excerpt":"After exploring \"newLisp\" in the past few posts, I would like to start looking at the \"D Programming Language\"\u00a0(DLang). DLang\u00a0has been around since 2001. It was originally created by Walter Bright and later Andrei Alexandrescu joined the team in 2007. The main inspiration for DLang was C++, although it uses\u2026","rel":"","context":"In "D Language"","block_context":{"text":"D Language","link":"https:\/\/www.rangakrish.com\/index.php\/category\/d-language\/"},"img":{"alt_text":"Lisp Function Called from D","src":"https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2021\/12\/Lisp-300x107.jpg?resize=350%2C200&ssl=1","width":350,"height":200,"srcset":"https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2021\/12\/Lisp-300x107.jpg?resize=350%2C200&ssl=1 1x, https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2021\/12\/Lisp-300x107.jpg?resize=525%2C300&ssl=1 1.5x"},"classes":[]},{"id":928,"url":"https:\/\/www.rangakrish.com\/index.php\/2018\/05\/27\/calling-go-functions-from-lisp\/","url_meta":{"origin":3017,"position":4},"title":"Calling Go Functions from Lisp","author":"admin","date":"May 27, 2018","format":false,"excerpt":"For the past few weeks I was travelling in the USA and had the pleasure of meeting several friends, some of whom are senior developers and architects. It was interesting to learn that many of them were either using Go language in their daily work, or were passionately endorsing the\u2026","rel":"","context":"In "Golang"","block_context":{"text":"Golang","link":"https:\/\/www.rangakrish.com\/index.php\/category\/golang\/"},"img":{"alt_text":"Part of Header File","src":"https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2018\/05\/Header-file.png?resize=350%2C200","width":350,"height":200,"srcset":"https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2018\/05\/Header-file.png?resize=350%2C200 1x, https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2018\/05\/Header-file.png?resize=525%2C300 1.5x"},"classes":[]},{"id":2765,"url":"https:\/\/www.rangakrish.com\/index.php\/2022\/04\/17\/calling-lisp-functions-from-xojo\/","url_meta":{"origin":3017,"position":5},"title":"Calling Lisp Functions from Xojo","author":"admin","date":"April 17, 2022","format":false,"excerpt":"A few days ago, I purchased Xojo Pro commercial license. In case you haven't heard about the product, Xojo\u00a0is a popular cross-platform development tool targeting Desktop, Web and iOS (Android is expected in the near future). It supports an Object-Oriented Basic language. It has been around for over 25 years\u2026","rel":"","context":"In "LISP"","block_context":{"text":"LISP","link":"https:\/\/www.rangakrish.com\/index.php\/category\/lisp\/"},"img":{"alt_text":"The Lisp Code","src":"https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2022\/04\/LispCode-300x168.jpg?resize=350%2C200&ssl=1","width":350,"height":200,"srcset":"https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2022\/04\/LispCode-300x168.jpg?resize=350%2C200&ssl=1 1x, https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2022\/04\/LispCode-300x168.jpg?resize=525%2C300&ssl=1 1.5x"},"classes":[]}],"_links":{"self":[{"href":"https:\/\/www.rangakrish.com\/index.php\/wp-json\/wp\/v2\/posts\/3017","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=3017"}],"version-history":[{"count":0,"href":"https:\/\/www.rangakrish.com\/index.php\/wp-json\/wp\/v2\/posts\/3017\/revisions"}],"wp:attachment":[{"href":"https:\/\/www.rangakrish.com\/index.php\/wp-json\/wp\/v2\/media?parent=3017"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.rangakrish.com\/index.php\/wp-json\/wp\/v2\/categories?post=3017"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.rangakrish.com\/index.php\/wp-json\/wp\/v2\/tags?post=3017"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}