Karthik Senthil2017-12-08T07:10:42+00:00https://karthiksenthil.github.ioKarthik Senthilkarthik.senthil94@gmail.com[GSoC 2016] Signing off from GSoC 2016 !2016-08-21T00:00:00+00:00https://karthiksenthil.github.io/2016/08/21/gsoc16<p>Hello all!</p>
<p>It has been a very interesting and fruitful journey this GSoC, specifically with the progress made in ruby_curry’s usability and range of programs that can be currently compiled with it.</p>
<p>There are still many avenues for improvements like :</p>
<ul>
<li> Completing CT_External.rb with all support for External functions </li>
<li> With introduction of suppport for Variables, many unimplemented edge cases can be implemented</li>
<li> A fully compiled, distributable binary for ruby_curry</li>
<li> More documentation regarding the details of ICurry and pipeline followed</li>
<li> Any interesting feature or extension to improve the performance of the compiler as a whole. Possible direction could be in ICurry translation module. </li>
</ul>
<p>The current status of the project can be viewed online <a href="https://github.com/karthiksenthil/ruby_curry">here</a>.</p>
<p>I would be more than happy to guide anybody interested in learning or pursuing any part of this work. The ultimate aim of ruby_curry is to act as an ideal research playground which can be used by students and researchers working on functional logic programming paradigms.</p>
<p>As always you can contact me via <a href="https://github.com/karthiksenthil">Github</a> or drop in an <a href="mailto:karthik.senthil94@gmail.com">email</a> about your queries regarding this work.</p>
<p>Looking forward to continue contributing to this prized project and overall to the dearest open source community :)</p>
[GSoC 2016] Progress in ruby_curry documentation2016-08-05T00:00:00+00:00https://karthiksenthil.github.io/2016/08/05/gsoc16<p>Last week I worked mainly on updating the document describing the design, execution and evaluation of ruby_curry. I was able to complete the “Translation” unit and have described the pipeline in this stage including a detailed account of RCurry - the Ruby based abstraction over ICurry. The progress can be observed <a href="https://github.com/karthiksenthil/ruby_curry/blob/master/docs/Documentation.md">here</a>.</p>
<p>I will next work on documenting the “Object code” and “Runtime” units. I will also be discussing with my mentor about the future work and directions for more work regarding this tool.</p>
[GSoC 2016] Documentation of ruby_curry2016-07-31T00:00:00+00:00https://karthiksenthil.github.io/2016/07/31/gsoc16<p>Due to upcoming time constraints I have decided to focus on the important task of documenting the design of ruby_curry. This will be a very critical document to guide any new developers interested in this project.</p>
<p>I have started initial work towards this and the current status can be viewed online <a href="https://github.com/karthiksenthil/ruby_curry/blob/master/docs/Documentation.md">here</a>. I will spend the upcoming week on the same task.</p>
[GSoC 2016] Documentation and upcoming tasks2016-07-21T00:00:00+00:00https://karthiksenthil.github.io/2016/07/21/gsoc16<p>The last week was focussed on some minor tasks like code cleanup, updating TODO and looking into implementations of equality-constraint operators like <code class="highlighter-rouge">cond</code> and <code class="highlighter-rouge">=:=</code>.</p>
<p>Since I am new to the Curry syntax and semantics it is taking some more time to understand the difference between these operators and coming up with Curry tests to differentiate between their execution. I will work on them over the next few days.</p>
<p>Along with this, I will also start work on documenting the overall design scheme, stages accomplished, assessment, evaluation pipeline, etc. of ruby_curry. This will act as a guide to anybody interested in continuing the current stage of work in the compiler system.</p>
<p>The progress of ruby_curry can always be tracked <a href="https://github.com/karthiksenthil/ruby_curry">here</a>.</p>
[GSoC 2016] Updates on external functions2016-07-16T00:00:00+00:00https://karthiksenthil.github.io/2016/07/16/gsoc16<p>Hello all!</p>
<p>I spent the last week working on tasks related to extending support for more external functions in runtime environment and integrating variables into different sections of ruby_curry.</p>
<p>After implementing free variables and the concept of Narrowing there are a couple of Curry examples which run into an infinite loop during runtime execution (<a href="https://github.com/karthiksenthil/ruby_curry/blob/master/curry_examples/last_1.curry">last_1</a>, <a href="https://github.com/karthiksenthil/ruby_curry/blob/master/curry_examples/length_narrow.curry">length_narrow</a>). We identified that this problem was arising due to a design issue in FlatCurry. We are planning to solve this by making changes to ICurry directly in order to bring about minimum changes in ruby_curry.</p>
<p>Apart from this, as mentioned in previous post, the generator table expressions are now bound freshly during runtime instead of compile time. I also worked on moving <code class="highlighter-rouge">integers</code> into a separate module <code class="highlighter-rouge">CT_Integer</code> which was a long pending task.</p>
<p>The upcoming tasks have been updated in <a href="https://github.com/karthiksenthil/ruby_curry/blob/master/docs/TODO">TODO</a> which mainly include new external functions like =:=, cond and solving some issues like support for variables in external functions.</p>
[GSoC 2016] Support for variables in ruby_curry2016-07-10T00:00:00+00:00https://karthiksenthil.github.io/2016/07/10/gsoc16<p>Over the last few days I was working on implementing the equation constrained operator (=:<=). After working on the <a href="https://github.com/karthiksenthil/ruby_curry/blob/master/lib/CT_External.rb#L141">first version</a> algorithm for it, we realised that support for variables was an important component specifically needed to test the operator.</p>
<p>We then worked on adding support for Variables both in compile time(object code generation) and runtime(execution). The concept implemented is also called <code class="highlighter-rouge">Narrowing</code>. This support was implemented by means of a generator table which maps a data constructor with token value 4 to an expression. Currently the expressions are bound during compile time, but it is preffered if the same happens freshly during runtime. This will be my next task of focus.</p>
<p>The support for variables can be found in this <a href="https://github.com/karthiksenthil/ruby_curry/commit/8528a5ca93090a6cb8f8e3f194541fc1d12be099">commit</a>.</p>
[GSoC 2016] Refactoring symbols and implementing External functions2016-07-05T00:00:00+00:00https://karthiksenthil.github.io/2016/07/05/gsoc16<p>The last week was focused on moving the Symbol definitions in the runtime environment to a separate ruby module, <a href="https://github.com/karthiksenthil/ruby_curry/blob/master/src/compiler/CT_Symbols.rb">CT_Symbols</a>. This involved a lot of changes to the structure of object code but in the end the module is very concise and accurate. We also tested all the existing test cases against the new module.</p>
<p>After that I implemented the <code class="highlighter-rouge">compare</code> External function as per the algorithm. Initially the comparison was done based on alphabetical ordering of symbol names for data constructors, but this was a mistake and was later corrected to comparison of token value instead. I also added a corresponding <a href="https://github.com/karthiksenthil/ruby_curry/blob/master/curry_examples/compare_test.curry">test case</a> for the same.</p>
<p>Next I will be working on the <code class="highlighter-rouge">=:<=</code> and the <code class="highlighter-rouge">=:<<=</code> operators which are described in this <a href="http://link.springer.com/chapter/10.1007%2F11680093_2">paper</a>.</p>
[GSoC 2016] Refactoring of expressions2016-06-30T00:00:00+00:00https://karthiksenthil.github.io/2016/06/30/gsoc16<p>Hello all!</p>
<p>I spent the last few days working on refactoring the old expressions.rb (in ruby runtime environment) into a revamped <code class="highlighter-rouge">CT_Expressions</code> module. This solves the issue of namespaces thus giving flexibility to names being used in the Curry programs. The entire module is divided into 4 files - <a href="https://github.com/karthiksenthil/ruby_curry/blob/master/src/compiler/CT_Expressions.rb">expression class definitions</a>, <a href="https://github.com/karthiksenthil/ruby_curry/blob/master/src/compiler/CT_Expressions_print.rb">expression printing</a>, <a href="https://github.com/karthiksenthil/ruby_curry/blob/master/src/compiler/CT_Expressions_equality.rb">expression equality</a> and <a href="https://github.com/karthiksenthil/ruby_curry/blob/master/src/compiler/CT_Expressions_utils.rb">expression utilities</a>. We tested this new module on all the existing test cases.</p>
<p>After this refactoring I moved ahead to implement the equality operation <a href="https://github.com/karthiksenthil/ruby_curry/blob/master/docs/equality-algorithm.txt">algorithm</a> in <code class="highlighter-rouge">CT_External</code> which has also been completed now.</p>
<p>I am now working on the Prelude compare operation based on this <a href="https://github.com/karthiksenthil/ruby_curry/blob/master/docs/compare-algorithm.txt">algorithm</a>.</p>
[GSoC 2016] Progress on External runtime functions2016-06-25T00:00:00+00:00https://karthiksenthil.github.io/2016/06/25/gsoc16<p>After the codebase merge a lot of new tasks and issues turned up. One of the important tasks is adding runtime support for externally defined functions in <a href="https://github.com/karthiksenthil/ruby_curry/blob/master/lib/Prelude.rb">Prelude</a>. I have made a complete <a href="https://github.com/karthiksenthil/ruby_curry/blob/master/docs/DOUBTS">list</a> of unimplemented External functions and their priorities. Current status of this module can be found <a href="https://github.com/karthiksenthil/ruby_curry/blob/master/lib/CT_External.rb">here</a>.</p>
<p>Before this task I also worked on making a more robust <a href="https://github.com/karthiksenthil/ruby_curry/blob/master/test/test_positives.rb">test suite</a> in ruby. All tests can be run using the <code class="highlighter-rouge">rake test</code> command and in order to force recompile all intermediate files from scratch for testing, the command <code class="highlighter-rouge">rake ftest</code> can be used.</p>
<p>I am currently working of refactoring <a href="https://github.com/karthiksenthil/ruby_curry/blob/master/src/compiler/expressions.rb">expressions.rb</a> to facilitate the definition of some External functions.</p>
<p>The complete list of upcoming tasks can be found <a href="https://github.com/karthiksenthil/ruby_curry/blob/master/docs/TODO">here</a>.</p>
[GSoC 2016] Merged Github repository with try server codebase2016-06-20T00:00:00+00:00https://karthiksenthil.github.io/2016/06/20/gsoc16<p>Over the last few weeks I have been adding all the development code to the try server codebase for immediate testing and rapid modifications. The tool has now reached a stable state which can be used to compile and execute simple Curry programs, and hence I have merged this development code with the stable Github repository for public viewing and usage.</p>
<p>The current code can be found on Github <a href="https://github.com/karthiksenthil/ruby_curry">here</a>.</p>
<p>The compilation pipeline details and usage of the tool is explained in the updated <a href="https://github.com/karthiksenthil/ruby_curry/blob/master/README.md">README</a>. There is also a <a href="https://github.com/karthiksenthil/ruby_curry/tree/master/test">test</a> suite to verify the working of the current status of the full system. The tests can be run by <code class="highlighter-rouge">rake test</code>.</p>
<p>ruby_curry can be setup and run by installing either PAKCS or KiCS on local machine. We plan on removing this dependency(by compiling into an executable) in the final release of the tool by the end of this GSoC.</p>
<p>Looking forward to add complete support and more features into the system in order to flawlessly compile a real world Curry application.</p>
[GSoC 2016] Cleanup and progress for mid evaluations2016-06-15T00:00:00+00:00https://karthiksenthil.github.io/2016/06/15/gsoc16<p>This week I’ve been working on tasks to prepare ruby_curry for a version release on Github and the GSoC mid evaluations.</p>
<p>I’ve added the module/namespace feature in the ruby object code and also provided support for integers in the runtime environment. I also did some code cleanup and removed obsolete code in the old codebase that is used on the try server.</p>
<p>This weekend I plan on merging the 2 repositories i.e try server codebase and Github repository. This would enable people to use the first minimal version of ruby_curry for their usage. I also plan on revamping the current test suite for the project. The updated list of TODO tasks can be found <a href="https://github.com/karthiksenthil/ruby_curry/blob/master/TODO">here</a>.</p>
[GSoC 2016] Progress in RCurry2016-06-12T00:00:00+00:00https://karthiksenthil.github.io/2016/06/12/gsoc16<p>Hello all!</p>
<p>Over the last week, I progressed in defining RCurry and correspondingly updated ICurryToAbstractRuby(the module to convert ICurry to RCurry). The current implementation can be used to compile and execute simple examples like <code class="highlighter-rouge">mynot</code> and <code class="highlighter-rouge">myappend</code>. There were many issues regarding lack of information available in ICurry which I tackled after discussions with my mentor. The source for <a href="https://github.com/karthiksenthil/ruby_curry/blob/master/lib/RCurry.curry">RCurry</a> and <a href="https://github.com/karthiksenthil/ruby_curry/blob/master/lib/ICurryToAbstractRuby.curry">ICurryToAbstractRuby</a> are available on the Github repository. A sample ruby object code produced by this version of the system can be found <a href="https://github.com/karthiksenthil/ruby_curry/blob/master/lib/mynot.rb">here</a>.</p>
<p>This week I plan on completing the full support for converting ICurry to RCurry and also improve the ruby runtime environment with features like Modules and Builtin data types. I also plan on working on a new test suite for ruby_curry by verifying the compilation made using ICurry and RCurry.</p>
[GSoC 2016] Introducing RCurry - An abstraction layer2016-06-05T00:00:00+00:00https://karthiksenthil.github.io/2016/06/05/gsoc16<p>Hello all!</p>
<p>As discussed in the previous post, we made a drastic change in the architecture of ruby_curry by utilising <a href="https://github.com/karthiksenthil/ruby_curry/blob/master/docs/ICurry.pdf">ICurry</a> to cover the compilation steps while providing a robust runtime environment in ruby.</p>
<p>My mentor and I had discussions about how cumbersome the task of directly converting <a href="https://github.com/karthiksenthil/ruby_curry/blob/master/lib/ICurryToRuby.curry">ICurry to Ruby</a> was. The feature set was limited and needed extra programming just to obtain some information for the Ruby object code. As a suggestion to solve this, we decided to introduce a layer of abstraction over ICurry - called RCurry. RCurry will be a code level abstraction of the information in ICurry i.e. in order to convert ICurry into executable code we add an abstract layer which can then be converted to object code in any language.</p>
<p>This would make the generation of object highly language independent. All one has to do is create a runtime environment for execution and develop a pretty printer(or converter) for translating RCurry into language of their choice. This logical partition also makes maintenance and development easy.</p>
<p>On these lines, I have been working on defining RCurry and a module to convert ICurry to RCurry called ICurryToAbstractRuby. These modules are currently a stub under development and being tested on the try server. I plan on making it available on the Github repo by the end of next week, along with a couple of tasks implemented from the TODO list … So stay tuned :)</p>
[GSoC 2016] Progress on translator system2016-06-02T00:00:00+00:00https://karthiksenthil.github.io/2016/06/02/gsoc16<p>Over the last few days I have been working on the ICurry to ruby object code translator system. I developed the first version which successfully produced executable object code for the simple mynot.curry example -</p>
<pre><code>
mynot.curry
data myBool = myTrue | myFalse
myNot myTrue = myFalse
myNot myFalse = myTrue
main = myNot (myNot myTrue)
</code></pre>
<p>The curry program for the translator can be found <a href="https://github.com/karthiksenthil/ruby_curry/blob/master/lib/ICurryToRuby.curry">here</a>.</p>
<p>Currently this program is not executable with the support available in the Github repository of ruby_curry. My mentor and myself have set up a temporary try server and repo to test development stubs since the ICurry library is itself big and difficult to set up.</p>
<p>There is a slight re-architecture in the flow diagram of ruby_curry :-</p>
<p>Curry source program —> ICurry library —> .icur representation —> Ruby executable object code</p>
<p>i.e we have moved the compilation computations to ICurry and implemented the complete runtime environment in ruby. This is to ensure better scaling and ability to handle larger Curry programs, which could not be achieved in a ruby based compiler.</p>
<p>There might be further changes to better this current architecture. I will post about the same when complete :)</p>
[GSoC 2016] Translator system for ruby_curry2016-05-29T00:00:00+00:00https://karthiksenthil.github.io/2016/05/29/gsoc16<p>I had a discussion with my mentor regarding a translator system which would handle the frontend parsing of Curry source program into an intermediate form suitable for the ruby_curry compiler. We concluded that it would be a better option to use an already implemented library for this task, called <a href="https://github.com/karthiksenthil/ruby_curry/blob/master/docs/ICurry.txt">ICurry</a>.</p>
<p>This library translates Curry source program into an internal representation. The ICurry representation contains the operation rules in the format of nodes of a graph. From initial reviews it looks like there is more than sufficient information available in this graph for ruby_curry.</p>
<p>The current idea is to use this graph data structure to construct the Rule objects. These objects can then be compiled into the ruby object code by building corresponding definitional trees. I will be spending the next few days working on this module for ruby_curry.</p>
<p>Apart from this I added a <a href="https://github.com/karthiksenthil/ruby_curry/blob/master/TODO">TODO</a> list to keep track of pending issues/features in the current state of the tool.</p>
[GSoC 2016] Backtrack bug solved2016-05-26T00:00:00+00:00https://karthiksenthil.github.io/2016/05/26/gsoc16<p>This post is to update about the current status of work in ruby_curry as part of GSoC 2016.</p>
<p>As mentioned in my previous post, I spent the last few days looking into options for the “translator” system and fixing the “backtracking” feature.</p>
<p>With respect to the solving the “backtrack” bug, I had to initially provide support for <code class="highlighter-rouge">CHOICE</code> in the frontend of ruby_curry. There were some issues regarding deep cloning(using <code class="highlighter-rouge">Marshal.dump</code>) while implementing this, which in fact taught me more about simpleton objects in Ruby. After adding support, I decided to test it with a slightly complex <a href="https://github.com/karthiksenthil/ruby_curry/blob/master/user/permute.json"> permute </a> example. The parsing passed but the output produced by the object code was incorrect due to the backtrack bug.</p>
<p>To solve the bug, I wrote down a simpler <a href="https://github.com/karthiksenthil/ruby_curry/blob/master/user/simple_choice.json"> simple_choice </a> example. And by using the stack trace and logging features I identified the problem to lie in assigning an unnecessary global variable :P</p>
<p>That solved the problem and I added a corresponding <a href="https://github.com/karthiksenthil/ruby_curry/blob/master/test/test_simple_choice.rb"> test case </a> for future reference.</p>
<p>Regarding implementation of the “translator” system, I am speculating into using an existing library. More details about this will be updated after discussions with my mentor.</p>
<p>Up next should be new features for ruby_curry like support for <code class="highlighter-rouge">where</code>, <code class="highlighter-rouge">loop</code> and <code class="highlighter-rouge">case</code> clauses, and probably an efficient type system for the compiler.</p>
[GSoC 2016] Coding phase - First post2016-05-23T00:00:00+00:00https://karthiksenthil.github.io/2016/05/23/gsoc16<p>Hello all!</p>
<p>As part of the initial stage of the Coding Phase, I had a discussion with my mentor regarding the immediate set of tasks/features to be implemented for the tool (picking from the points highlighted in the proposal). The following are tasks at hand:</p>
<ol>
<li> <b>translator</b> - A system to translate Curry into a format that is suitable for ruby_curry compiler. At the moment we aim to directly translating Curry to JSON if possible with definitional tree information. </li>
<li> <b>backtracking</b> - The compiler has a stack based backtracking feature to handle CHOICE in Curry. However this module seems buggy and fails for certain examples.</li>
<li> Quality and type system </li>
</ol>
<p>In addition, I have also added a new test framework to ruby_curry which will enable to integrate all unit tests. This will be beneficial in continously testing the new changes that are being made to the compiler or other relevant modules of the tool.</p>
<p>To integrate all tests, I added a <a href="https://github.com/ruby/rake">Rake</a> task for tests. All the current unit tests can be run by the <code class="highlighter-rouge">rake test</code> command in the base directory of ruby_curry. The commit for this change can be found <a href="https://github.com/karthiksenthil/ruby_curry/commit/d59d1108c19003efeef8b111794546f40412cab5">here</a>.</p>
[GSoC 2016] Completion of status report2016-05-18T00:00:00+00:00https://karthiksenthil.github.io/2016/05/18/gsoc16<p>I have completed the brief status <a href="https://docs.google.com/document/d/1O6udc8el6X_P1nZt1bk_gMCTw0W4PY-swhsPnx1Fs-o/edit?usp=sharing">report</a> of the current ruby_curry codebase. The report is organised into 3 main sections -</p>
<ol>
<li> Installation/Usage instructions </li>
<li> Code Workflow </li>
<li> Directory-wise file descriptions </li>
</ol>
<p>The primary purpose of the report is to document the current work so as to comprehensively evaluate the tool from scratch. The evaluation will aid in planning the first set of steps to be undertaken in the upcoming “Coding Phase” of GSoC. The document will also aid the users interested in using the current version of ruby_curry.</p>
<p>Please leave your comments/suggestions in the report :)</p>
<p>Looking forward to start the Coding Phase !</p>
[GSoC 2016] Codebase status report and installing KiCS22016-05-13T00:00:00+00:00https://karthiksenthil.github.io/2016/05/13/gsoc16<p>Hello all!</p>
<p>This post is to update about my progress in generating a status report for the ruby_curry codebase. I have logically divided the code repo into components and have started documenting the working of each component. The ongoing copy of the report can be viewed <a href="https://docs.google.com/document/d/1O6udc8el6X_P1nZt1bk_gMCTw0W4PY-swhsPnx1Fs-o/edit?usp=sharing">here</a>. I will continue updating this document over the next week.</p>
<p>Regarding the installation of <a href="https://www-ps.informatik.uni-kiel.de/kics2/index.html">KiCS2</a>, I carried out the following steps :</p>
<ol>
<li> installing GHC(The Glasgow Haskell Compiler) and Cabal </li>
<li> downloading tar of latest release of KiCS2 and building natively </li>
</ol>
<p>Intitally the Haskell compiler choked at linking as it by default used the <b>ld.gold</b> linker. This is a known <a href="http://stackoverflow.com/questions/13046319/haskell-ghc-compiling-linking-error-not-creating-executable-linux">issue</a> which I solved by purging binutils-gold as suggested <a href="http://stackoverflow.com/a/13046709">here</a>.</p>
<p>After this step, the KiCS2 build again failed with Cabal failing to install some packages due to unmet dependencies. I am currently working on getting around this issue. The missing dependencies include <i>comonad 5</i>, <i>semigroupoids-5.0.1</i> and <i>mtl-2.2.1</i>. I have tried natively installing these dependencies from source(Github), but the build still seems to fail for same reason. I will try other possible steps to solve this problem and go ahead with exploring the features of KiCS2.</p>
[GSoC 2016] Installing PAKCS2016-05-09T00:00:00+00:00https://karthiksenthil.github.io/2016/05/09/gsoc16<p>I spent the last few days surfing through the current codebase in ruby_curry in order to identify the code workflow for a single run of the tool.</p>
<p>I have also started documenting a directory wise description of files for the status report which should be available soon.</p>
<p>With regards to installing PAKCS on my local machine, I followed the instructions provided <a href="https://www.informatik.uni-kiel.de/~pakcs/download.html">here</a>. I already had an updated version of <a href="http://www.swi-prolog.org/">SWI-Prolog</a> and hence went ahead to just download the Linux(64 bit) release of <a href="https://www.informatik.uni-kiel.de/~pakcs/download/pakcs-1.14.1-amd64-Linux.tar.gz">PAKCS v1.14.1</a>.</p>
<p>The build took quite some time, but towards the end it was a smooth install. I could verify the working with the <a href="http://www-ps.informatik.uni-kiel.de/smap/smap.cgi?download/1/1">Naive Reverse</a> example.</p>
<p>An interesting feature in PAKCS is the curry2xml tool (using :xml in the REPL). This caught my attention as ruby_curry also aims to convert FlatCurry into JSON(in the frontend) for further processing into Ruby object code. So I’m looking into the working and features of this tool in PAKCS before implementing a similar idea for JSON in ruby_curry.</p>
[GSoC 2016] Community Bonding - First Post2016-05-07T00:00:00+00:00https://karthiksenthil.github.io/2016/05/07/gsoc16<p>Hello all!</p>
<p>This year as part of Google Summer of Code 2016 I will continue working on <a href="https://github.com/karthiksenthil/ruby_curry">ruby_curry</a>, extending it to a full fledged compiler implementation for FlatCurry, a flavour of the functional logic programming language <a href="https://en.wikipedia.org/wiki/Curry_(programming_language)">Curry</a>.</p>
<p>More details about the project can be found <a href="https://summerofcode.withgoogle.com/projects/#4517222395412480">here</a>.</p>
<p>After discussions with my mentor, Prof. Antoy, I have decided to spend the initial part of the Community Bonding period for the following -</p>
<ol>
<li> Status Report - detailed draft of current status of ruby_curry w.r.t. features and bugs </li>
<li> Setting up <a href="https://www.informatik.uni-kiel.de/~pakcs/">PAKCS</a> and <a href="https://www-ps.informatik.uni-kiel.de/kics2/">KiCS2</a> on local machine </li>
<li> Survey on the above compilers </li>
</ol>
<p>Looking forward to learn more :)</p>
<p>P.S. : And yes, this year I will update about my progress in this project through regular blog posts on my personal website itself.</p>
Multrix - A tool for dynamic dependence analysis of a program2015-08-18T00:00:00+00:00https://karthiksenthil.github.io/2015/08/18/multrix<p><em>A project undertaken in the <a href="http://hpc.nitk.ac.in/">HPC Research Group</a> at National Institute of Technology Karnataka, India</em></p>
<p>Multrix is an automatic, dynamic and language-independent tool to construct the Node Dependency Matrix(NDM) of an input program. It uses dynamic binary instrumentation techniques to identify dependencies at instruction level in the input program, and reprsent the same using the NDM.</p>
<p>The Intel PIN DBI framework was used for instrumentation. Pin provides great flexibility in analysing executables with features to insert stubs or breakpoints in the running program. A custom program written using the Pin API to analyse running programs is a called PinTool.</p>
<p>Usage and execution cycle in Pin :</p>
<ol>
<li>Design Pintool to perform required analysis</li>
<li>Compile the Pintool into an <code class="highlighter-rouge">so</code> file(shared object)</li>
<li>Attach the file to the program and execute it</li>
</ol>
<p><em>Work in progress</em></p>
What is HPC?2015-06-24T00:00:00+00:00https://karthiksenthil.github.io/2015/06/24/whats-hpc<p>High Performance Computing(HPC) is becoming a trending term in Computer Science. Here is my view or definition of HPC in layman words.</p>
<p>As humans we are bound by the performance metric in any activity that we pursue, constantly aiming to improve this metric. So it is unsurprising that computing devices these days are also striving to give their best performance.</p>
<p>In my view, HPC can be defined as any activity that reduces computation time of a process on a computing device and accordingly shows signs of improvement(large or small-scale) in performance. Even the smallest step of reducing unecessary iterations in a for-loop can be a simple step towards high performance computing. A tool which emphasises this : <a href="http://karthiksenthil.github.io/2015/08/18/multrix/">Multrix</a>.</p>
<p>So HPC doesn’t just refer to large scale parallel architectures or huge clusters of CPUs and GPUs with millions of cores. The simple small-scale optimizations that when implemented conserve our computation resources are the activities that define and drive HPC.</p>