Creating a Julia Executable

I did this yesterday, but only started the blog today...

It is possible to create an executable file from a Julia script, with a little bit of effort. Basically, we need to create a Julia package project, and then use the PackageCompiler library to turn this into an executable: 

Process to create a Julia package

  1. Launch an interactive julia session
  2. Press the "]" key, the Julia prompt will be replaced with a pkg prompt:
  3. (@1.4) pkg>
  4. Type "generate <packagename>" This will create a new package with the given name. In doing so, it will create a directory with the same name, which will include a "src" subdirectory, and a Project.toml file which describes the project to Julia
  5. Activate the project by typing "activate <packagename>"
  6. Add any and all dependencies used by the project. This is done via the "add <package>" command, which can accept more than one package name at a time. This will update the "[dep]" section of Package.toml, and create/modify the Manifest.toml file.

Process to compile the script
  1. From a regular Julia prompt, type
    using PackageCompile
    create_app("<PackageName>", "<PackageName>Compiled", force=true)
  2. This will create a new directory, which will contain a "bin" subdirectory. The executable will be in this subdirectory
Some notes
  1. Julia becomes quite anal about loading symbols from C libraries when compiled this way. Basically, trying to store the open library and/or symbols globally doesn't work. The workaround I have found is to pass the open library around between Julia functions, and have each function extract whatever symbols they need.
  2. This is actually a standard problem when we load non-local modules, it turns out. For a general library wrapper, where we don't want to pass the library betweene functions, it appears that making the call to Libdl.dlopen at the top of each function does not introduce any appreciable overhead.

Comments

Post a Comment

Popular posts from this blog

Creating a Node-Node Connectivity Array

Image
So for ALE/SALE, we need a connectivity array linking nodes together. Let's look again at part of our mesh: This time, I have labelled both the cells and the nodes. Let's consider node 114 - we need to create a node-node connectivity, nodnodconn, such that: nodnodconn[1, 114] = 113 nodnodconn[2, 114] = 118 nodnodconn[3, 114] = 56 nodnodconn[4, 114] = 57 We currently have two pieces of information which we can use to construct this connectivity: The identities of the nodes surrounding any given cell (nodelist) The orthogonal neighbours of any given cell (elelconn)  Let's look at how we might map our nodnodconn array onto a simple 4 cell/9 node stencil: Here, we would be looping over cells rather than nodes, and our aim is to create the nodnodconn entries for N0. I.e: nodnodconn[1, N0] = N1 nodnodconn[2, N0] = N2 nodnodconn[3, N0 ] = N3 nodnodconn[4, N0 ] = N4 The positions of the node labels in the diagram shows the easiest way to access them given ...
Read more

Creating an Element-Element Connectivity Array

Image
So for certain features of the hydrodynamic solve, such as a Christensen Q, and ALE/SALE, we need some form of element-element connectivity array. Consider the following mesh fragment: The aim of the connectivity array is to link cell 13 to its four orthogonal neighbours, 8, 12, 14 and 18. Specifically, however, we want an array of size [4,ncells] where the first index corresponds to the directions down, right, up, left in that order. I.e: elelconn[1,13] = 12 elelconn[2,13] = 18 elelconn[3,13] = 14 elelconn[4,13] = 8 In order to calculate this array correctly, we first need to look at how GMSH generates the cell-node connectivity. Turns out we have control of this, via the Transfinite Surface input. We'll set up the input file so that it creates the following node ordering (in nodelist): Here the green numbers show how the nodes are ordered (i.e. indices of nodelist), whilst the red numbers show (again) how we want the edges to be numbered (i.e. indices of elelcon...
Read more