I am just a normal person. -I love to build stuff and a huge believer in randomization.
If you would like to have a one of one chat you can initially email me with -the email me@akilan.io. I will normally respond within 24 hours and at the worst -case 48 hours.
A flight simulator is a device that artificially re-creates aircraft flight and the environment in which it flies, for pilot training, design, or other purposes. It has been really popular since 1982. The first release was called subLogic flight simulator which was released in 1979 on the Apple II.
Since this release flight sim has completely evolved with newer versions with newer features which means more and more accurate modelling of newer aircrafts.
Flight sims have also become part open source. The current best flight simulator in the market Xplane 11 has open source modules such as BetterPushBack , SharedCockpit etc … In recent years flight school students can even skip most of the instrumental classes for aircrafts such as the Ceesna’s due to the fact that they have already learned it in the flight sim at home.
Before we start the discussion of FS2020 we need to compare the current progress of their competitor Xplane which is designed by a Software Company called Laminar research. Xplane 11 is the current best Flight sim platform out there. Xplane 11 comes built in with VR compatibility , Runs on all platforms such as Mac , Windows , Linux and the graphics speaks for itself and runs on most common Pc’s on today’s standards.
The release date of FS2020 is still unknown due to COVID19 delays. All we know is that it should be coming out sometime this year. The idea is that the game is rendered on your PC but the scenery is downloaded from the azure servers. The reason it has a lot of hype is because of the fact that it’s graphics is game changing and even the amount of realism that they have added to the game (We will talk more on this later).
The game has an online and offline maps. The Hype comes from the online maps as it’s a 3D map from Bing. With the current technology, satellites are able to take a picture of cities from different angles and generate 3D models out of them and the game developers have been using a lot of machine learning techniques to generate the tiniest details such as grass ,trees , cars on the road etc.. There have also been very funny comments on these 3D maps such as “Tips on how to tour north korea”, “How to catch your wife cheating”,“This video gave me morning wood. Girlfriend thought it was because of her. Yea honey….it’s totally you.” etc…
This link will give you a general idea on 3D models of cities look like
For higher details many of the major airports are modeled partially manually. The movement ground crew and vehicles are all a bunch of AI’s working in parallel. The details of the runway and taxiway are super high. In the demo we can even see tiny stones on the taxiway.
As per the developers the 3D models are generated using Photogrammetry data or else it’s augmented bitmap which means that the base image is from bing maps and then it’s filled with some pre-build objects. The size of the bing scenery which they use is around 2 Petabytes and this is only one aspect of the Sim. All the maps are generated or drawn based on the horizon and this varies based on the height of the aircraft.
Again for the weather there is online and offline data. Is it actually interesting to know that simulating or modeling the weather is as complex as doing it for the ground. To simulate that the game generates millions of virtual particles to generate accurate lift for the aircraft. In many other sims the stalls in the code have been like flags (i.e on and off switch) this means that when the aircraft loses speed the nose dive will be a bit unrealistic. This has been fixed in FS2020 and they calculate various aspects such as density of air , wind patterns because at many times the aircraft would not even stall due to the design of the hardware which automatically pushes the nose down to gain speed. FS2020 can even predict which direction the aircraft will stall at.
The developers had to use a fresh approach to ensure that the lighting effects have to be as realistic as possible and to also accommodate all new techniques coming out from the video game industry. They have their own scattering system which gets lights from unified sources such as Sunlight ,Moonlight ,Starlight ,City light etc… The photons are scattered based on the parameters such as humidity , weather , pollution etc … The shadows of the clouds are casted on the ground , shadows of the ground have been casted on the clouds and so this gives unbelievable sights.
The sim has volumetric 3D rain , volumetric Rainbow scattering; this means that the rainbow is generated based on the compositions required to generate one. Each water droplet on the windshield is generated based on the speed of the aircraft and as the aircraft speed varies this impacts on how much the water is stretched in the windshield of the cockpit.
The sim even has window icing that takes place mostly in the cruise altitude if the Anti ice systems are not turned on in the aircraft.
The position of the sun , moon and stars will be informed based on date and time of year and even the light of the city will be reflected back to the cloud which creates realistic VFR flying. The reflection of the building on water is also realistic based on time of day, number of clouds etc.. and it is rendered the same way as how the atmosphere is rendered.
This is one of the best features for anyone flying aircraft’s through clouds. There are 32 layers from sea level and they are based on density , shape , fuzziness and all these clouds can be seen from any angle. The formations are informed based on the updraft winds. The sim natively supports all types of clouds. The max view distance of generated clouds is 600 km.
The weather data is collected from one of the research centers in Switzerland. Based on data provided to the engine, The corresponding clouds and updrafts are generated. The sim gets upto 32 layers of real world cloud data, pressure , humidity, temperature, wind speed and gusts.
Just graduated looking for remote or work based in the UAE.
Mental challenges I face when working on open source project I created called P2PRC.
Closer towards a future where it’s hard to compare reality and simulation
I am current working on my PhD experiments on CHERI based capability system. -Read more
I am currently looking for work as a part time software engineer (Max 17 hours a week). What I -am capable of building is what you see in my website.
I am happy to have a conversation with interested employers :)
Okay so P2PRC is a technical topic atleast for me as it’s about a peer to peer networks that is designed for computation. This post is about how I feel mentally working on this project. What I am talking about in this post can be linked to how I feel working in -any of my personal projects.
At the current stage of P2PRC, I have been trying to use my free time on trying to build a binary that just works. I know it’s being -optimistic but I am way over my head at many instances. The painful -part for me is figure out how to get this project at a useful state.
At the current moment P2PRC project is like me talking to myself. -Example I create an Issue , fix it and review my own code. It’s like taking to yourself. This is fine initially but it just feels -extremely (i.e in kind words) lonely. No one is blame for this -but it’s a true fact in my case simple as that.
I have no idea on why I keep working on this project. I guess -maybe it’s just that I have fun doing it. The true fact is that it -is fun at times and really lonley at many times. As a hacker or -Open Source developer (i.e call it whatever you like). The important thing would just be feedback and hopefully feeling -happy on what you built.
I promoised that I would continue this project for 3 more years and -see how it continues from there. The project is at the very initial stages and very tough to say what would be it’s fate. The aim of this was to be helping hand towards the main aim of creating a distributed game engine. But at the moment have no clue on how a -game engine works.
Edinburgh the only sunny city in Scotland!!!
Path information: https://www.walkhighlands.co.uk/fife-stirling/the-binn-burntisland.shtml
A really easy and relaxed walk. Can be easily done no matter the weather condition. -From the previous hikes done so far one of the most well connected hikes (In terms of public transport) especially from the Edinburgh side.
This was taken from the highest peak and shows -an impressive view of the small town with Edinburgh across the sea. North bridge is barely visible due to the clouds.
While walking through the trail we intended to take -a deviation to walk through the Fife costal walkway -to walk closer to the sea. There is a small caveat, the segment of costal walkway can only be traversed -on a low tide (Unless you are Moses). -The annoying part was that there was a relatively high tide which we didn’t notice blocking parts of the path. The worst case scenario would be to walk back to the start of the costal path and walk along side the road to city centre. The picture above reflects one of the deviated paths we could have taken but unfortunately private property had fenced out path way from the public from using it (This was a bit frustrating). When walking through the partially blocked pathway a nice view of the sea could be captured.
Rocky parts which had to be crossed through the costal walkway.
Start of the costal walkway from the fancy golf course. Crossing the golf course is part of the trail. Heading -to the beach is not part of the documented path on the trail provided in Walkhighlands.
The hike with best weather so far in the warmest Scottish winter.
Really cute public transport for the last stretch and great view of the highlands
Day trip walkaround the principality of Monaco
A random stream of water which my flatmate is tempted to row in. You wouldn’t believe me but I have normal friends.
Path: https://www.walkhighlands.co.uk/perthshire/sron-a-chlachain.shtml
First identified rainbow, this was the first instance of the gayness unleashed (Still straight though). I don’t have a picture -but there was a double rainbow by basic arithmetic makes you straight as well.
Proof that no one was tortured during this hike. I am not liable to people having -traumatic memories listening to -me talk for 4 hours straight :-).
Oww look another rainbow with camel humped style hills in the background. Don’t get fooled by the weather the path was pretty swampy.
Wee beauty!
As part of my eurorail travelling did a day trip city walk through the Principality of Monaco. It’s unbeleivable how small the country really is. You can mistakenly cross the border by just doing a relaxed walk! It gives you the feeling of downtown Dubai but with mountains in the surrondings and significantly better weather.
For those lazy asses! It’s not hard to spot escalators to help gain your step count.
-
I am going to make you guess where monaco ends! (hint: Not the part that has british inspired roads). While walking if you notice an environment change feeling deserted you have probably left Monaco.
-
Do enjoy the beautiful blue sea and it’s defintely worth heading in-person. You will
-see a lot of rich people. Don’t worry so long as the plastic is on thier body and not on the sea it’s good for everyone!
-
You cannot mention you have gone to Monaco without spoting a fancy car with the view of the city! The policing was amazing, even with fancy cars the road discipline was fantastic.
-
The principality is so small that below the city is basically car parks and tunnels all around the city. The car city planning is amazing. Although I hate car based cities.
-
The entire city is stunning you can admire the real beauty as you head towards the sea. If you have head phones I recommend lisenting to the Album “Death of a Bachelor” by Panic! At The Disco.
-
It’s a boat that is really slow. I would rather buy more lego!
-
“P2PRC—A Peer-To-Peer Network Designed for Computation” (https://link.springer.com/chapter/10.1007/978-981-16-7618-5_45)
“Benchmarking Parallelism in Unikernels” (https://researchportal.hw.ac.uk/en/publications/benchmarking-parallelism-in-unikernels)
The purpose of this project is to do a benchmark run when ever there is a push. The background activity is fairly simple, we create our own bare metal server. Once this server is created we run a bunch of ansibles(for sysbench) and once the run is complete we read the results and store them in a mysql instance. Once the following operations are complete we take down the server.
We have designed a simple static website generator which can be designed to be interacted via Rest Api’s. We have demonstrated how a user can create a static webpage from WhatsApp. The intention of this project is to prove simplicity of having static websites.
The demo interaction is done using a whatsapp bot to interact with Rest Apis.
p2p network that creates containers and eventually helps in harnessing the computation power.
intergrating benchmarks for the open source repository vitess
Creating a custom static website engine which can be accessed by using RestApi
Prototype Implementation of energy transcations in a micro grid.
-This project aims to create a marketplace where anyone generating energy by using renewable sources can sell it to anyone in the grid. This will in most cases will be cheaper and aims to have no carbon emissions.This entire platform has two versions, a centralized and a decentralized version.The centralized version uses the client-server architecture while decentralized version uses the concept of a transactional battery along with relay modules which is used to forward and receive power from other batteries. We were able to transfer energy from one power bank to the other using relays.
The main aim of this project was to create a custom peer to peer network. The user acting as the client has total flexibility on how to batch the tasks and the user acting as the server has complete flexibility on tracking the container’s usages and killing the containers at any point of time.
Maintainer of a project I created and currently developing. P2PRC is a p2p network designed to orchestrate custom tasks on a P2P network. The project is built entirely using Go Lang.
Go, Haskell, Python
October 2021 - November 2023, Remote (Prague, Czechia)
Worked on the open source project (https://github.com/PeernetOfficial/core).
August 2021 - March 2022, Remote (Dubai, UAE)
Worked on Read Solomon error corrections for finger printing audio signals and -worked with Maman with smaller consultancy work.
September 2021 - Present, Remote (Riyadh, Saudi Arabia)
Took over the Karaz back end development as apart of mutual agreement to switch over from -Maman to Karaz. Initially built the entire back-end system for Karaz which included reverse -engineering glucose devices and extracting data from such devices. As the company grew recruited -back-end developers to do most of the maintenance and feature building.
Go, Python, Javascript, Kotlin, Java
August 2020 - March 2021, Remote (San Francisco, California, United States)
Working on an open source project to benchmark the project Vitess (A database clustering system for horizontal scaling of MySQL).
Project: Vitess Arewefastyet
November 2018 - May 2021, (Dubai , UAE)
My role as tech club president is to work on projects that seem to help towards building a strong community.
September 2017 - July 2021
Major courses completed:
January 2022 - Present
The increasing disparity between application workloads and the capacity of Translation Lookaside Buffers (TLB) has prompted researchers to explore innovative solutions to mitigate this gap. One such approach involves leveraging physically contiguous memory to optimize TLB utilization. Concurrently, advancements in hardware-level system security, exemplified by the Capability Hardware Enhanced RISC Instructions (CHERI) architecture, offer additional opportunities for improving memory management and security. -CHERI introduces capability-based addressing, a novel approach that enhances system security by associating capabilities with memory pointers. These capabilities restrict access to memory regions, thereby fortifying the system against various security threats. Importantly, the mechanisms implemented in CHERI for enforcing memory protection can also serve as accelerators for standard user-space memory allocators. By leveraging capability-based addressing, memory allocators can efficiently manage memory resources while ensuring robust security measures are in place.
P2PRC as a abstraction
Allocating ports to plugins P2PRC
Prototype Implementation of energy transcations in a micro grid.
Basics of running power and cheap IT infrastructure
intergrating benchmarks for the open source repository vitess
Brainstroming ideas to run distributed tasks locally
Day trip walkaround the principality of Monaco
p2p network that creates containers and eventually helps in harnessing the computation power.
Prototype Implementation of energy transcations in a micro grid.
Brainstroming ideas to run distributed tasks locally
P2PRC as a abstraction
Closer towards a future where it’s hard to compare reality and simulation
Based on a Website generator built by hw tech club
Creating a custom static website engine which can be accessed by using RestApi
The hike with best weather so far in the warmest Scottish winter.
Really cute public transport for the last stretch and great view of the highlands
Day trip walkaround the principality of Monaco
Really cute public transport for the last stretch and great view of the highlands
The hike with best weather so far in the warmest Scottish winter.
Really cute public transport for the last stretch and great view of the highlands
Prototype Implementation of energy transcations in a micro grid.
Closer towards a future where it’s hard to compare reality and simulation
Basics of running power and cheap IT infrastructure
Modifying the open source project laplace to allow remote keyboard and mouse during screenshare
Prototype Implementation of energy transcations in a micro grid.
Annoying NAT boo boo
Basics of what is RISC-V
Just graduated looking for remote or work based in the UAE.
p2p network that creates containers and eventually helps in harnessing the computation power.
Mental challenges I face when working on open source project I created called P2PRC.
Annoying NAT boo boo
Allocating ports to plugins P2PRC
P2PRC as a abstraction
Plugin Module implementation P2PRC
Alpha release for P2PRC
Really cute public transport for the last stretch and great view of the highlands
Plugin Module implementation P2PRC
Allocating ports to plugins P2PRC
Mental challenges I face when working on open source project I created called P2PRC.
p2p network that creates containers and eventually helps in harnessing the computation power.
Creating a custom static website engine which can be accessed by using RestApi
Basics of what is RISC-V
The hike with best weather so far in the warmest Scottish winter.
Creating a custom static website engine which can be accessed by using RestApi
Allocating ports to plugins P2PRC
Prototype Implementation of energy transcations in a micro grid.
Alpha release for P2PRC
intergrating benchmarks for the open source repository vitess
Modifying the open source project laplace to allow remote keyboard and mouse during screenshare
Based on a Website generator built by hw tech club
Creating a custom static website engine which can be accessed by using RestApi
Just graduated looking for remote or work based in the UAE.
In this blog post we will talk about the project custom website generator which hw tech club contributors created. Before that a bit of basics of how static website generators work. In the current scenarios websites are either rendered in the front end using React/Vue or in the backend using Jinga , express etc … The flaw in the front end is that websites use a lot of CPU memory from the Client side to load webpages and rendering on the backend does fix this issue but is still relatively more expensive than loading static web pages. A static website generator basically generates static web pages only when content is changed.
There are many static generators such as Hugo and Jenkyll which are super efficient and do a great job in generating static web pages. The only problem is both are human readable and not Api friendly which made it initially tough for us to interact with it. Ex: Hugo has many variations and with Yaml , Toml and creating an Api to store these states and ensuring to populate according to the template was super painful for us.
To build a simple website generator that can take a JSON file of any shape and populate it to the according website template. The only catch is that both the JSON shape and fields that should be populated in the template should be of the same shape. The implementation of this was done using Node js as that was the only language me and my friends were familiar with at that time.
There are bash scripts added to make it possible to deploy websites generated to IPFS (Interplanetary file system). This is to ensure that your generated website can be deployed on a peer to peer network.
The following project is released on GPLv2 hence it is completely open source and we accept contributions from all developers.
We have only covered the high level overview of this project and there are other modules not talked about like the whatsapp bot to interact with this Api.
mDNS or called multicast DNS is just a DNS over a local network. mDNS is also considered as a Zero configuration technique. It can be used to discover nodes in a local network (ex: Apple’s bonjour).
Assuming all machines are running a linux kernel. All nodes in the network can have an SSH server and can broadcast each other’s public key. All the nodes can add broadcasted public keys to their authorized_keys file. This is assuming it’s done in a local private network (i.e not a secure solution but an easier way). Now all nodes can SSH into each other.
To render tasks DrQueue seems to be a promising choice. DrQueue is an open source render farm system. Similar to Farmer-Joe-Render. DrQueue is used in the Visual effects ,science and finance industry. The objective of DrQueue is batch tasks and run as a task management tool for multiple nodes. DrQueue is compatible on Windows, macOS, Linux, Irix and FreeBSD. DrQueue can be used with any renderer that supports a CLI(Command Line Interface). DrQueue auto generated scripts for Blender, Maya, Lightwave, Cinema 4D, Maya, lightwave, Mental Ray, After Effects, Aqsis, 3Delight, Pixie, Snake , Terragen and Nuke. DrQueue makes it possible to talk to master and slave nodes with a custom API which any user can create based on the inbuilt functions.
This is just a thought in my mind of a logical and simple way to run tasks distributed. This is really important as we underestimate the computing power we have if we use our home devices collectively. We could start pushing game developers to start building games for distributed systems. Imagine if FS2020 could be rendered distributed :).
Annoying NAT boo boo
Allocating ports to plugins P2PRC
P2PRC as a abstraction
Plugin Module implementation P2PRC
Modifying the open source project laplace to allow remote keyboard and mouse during screenshare
Alpha release for P2PRC
Basics of what is RISC-V
Brainstroming ideas to run distributed tasks locally
Basics of running power and cheap IT infrastructure
Based on a Website generator built by hw tech club
Although the current cost of IT infrastructure is relatively minimal cost these days. We can still dramatically reduce the cost further. A good IT infrastructure is the fact that we rely less on 3rd party companies and they are simple to run. When we mean simple it does mean a fancy UI where everything is drag and drop. Using a terminal can be your best friend and save you a lot of time. Like any skill you need to use it regularly to reap the benefits. It is very important to stay minimal to sustain your IT infrastructure for a longer period of time.
If you run a windows server then stop it. Always use an Open source OS over Proprietary. Transition is an open source OS (i.e Ubuntu , Debian) is relatively easy. To start off use a VPS to host your servers (i.e Digital Ocean, Vultr) . The main reason to use a VPS is the fact that you get an static IPV4 address. You pay for the hour rather than the month. If you think something is wrong in your server you can back it up and delete the server. Saves a lot of time on your side.
If you have an inhouse server, You can either get a static IPV4 address or use a DDNS if it is expensive (i.e so that someone can access it from outside your company network). There are many free training courses to learn how to use a linux server and configure it. This means you can be self-reliant and not rely on other companies to configure your server.
The main benefit is that there is no licensing cost and you have access to the source code. For Example : The linux community is really big and OS keeps getting updated frequently that means if a new vulnerability is found its most likely fixed really quick. The concept of open source OS is simple if you break it then just back up data and reinstall the OS.
Git is a version control system which can be used to store documents or codebase. Using it is the best way to store your company information in a secure way. It recommended you run it on your company server (Recommended to use Gitlab). If you want you can use github ( :) Owned by microsoft) .
For your email you can set up your own mail server(i.e https://github.com/maildev/maildev) or use Migadu which is extremely cheap. There are so many alternatives for word , excel etc .. ( i.e LibreOffice , Apache Open Office , Google Suite etc…). If you want to have your own conference on your own server or on outside server use Jitsi.
For any tool which is paid there is an open source alternative.
If you are planning to have a website which is either an E-commerce website or a normal company webpage there is no point of a database like Sql unless your website is really huge. I would recommend using static website generators like Hugo and either design your theme or use the ones available online. In most cases you only need to only use static generators for your company page and your basic e-commerce website.
If you use a static website generator you can either deploy it on places like netlify for free of cost or deploy them on your server.
" Laplace is an open-source project to enable screen sharing directly via browser. Made possible using WebRTC for low latency peer-to-peer connections, and WebSocket implemented in golang for WebRTC signaling. "
link: https://github.com/adamyordan/laplace
Link to my branch which has Barrier intergrated with Barrier KVM: -https://github.com/Akilan1999/laplace/tree/keyboard_mouse
Link to the pull request: https://github.com/adamyordan/laplace/pull/8
To do this we ensure that the client either has has a IPV6 -address or a public IPV4 address. -We use the use the popular open repository known as Barrier KVM.
“Barrier is software that mimics the functionality of a KVM switch, which historically would allow you to use a single keyboard and mouse to control multiple computers by physically turning a dial on the box to switch the machine you’re controlling at any given moment. Barrier does this in software, allowing you to tell it which machine to control by moving your mouse to the edge of the screen, or by using a keypress to switch focus to a different system.” Barrier KVM
| Platform | Build Status |
|---|---|
| Linux | |
| Mac | |
| Windows Debug | |
| Windows Release | |
| Snap |  |
$ git clone https://github.com/adamyordan/laplace.git
-$ cd laplace && go build -o laplace main.go
-$ export LAPLACE = $PATH
-$ ./laplace --help
-$ ./laplace -setconfig
-$ ./laplace -tls -addrs <ip address>:<port no>
-Note: ensure you are running none using Sudo
The machine that wants to control the screen needs to either be:
After 5 months of working on this project. I would be glad to announce that we -have a alpha release. The objective of P2PRC is to create a p2p network where nodes -can share each others computatination power in a virtualized manner (i.e digital -ocean where anyone can share resources). In the alpha release the choice of -virtualization used is docker. The current release will -support docker. It should be noted that from the next release onwards we will -not support the docker daemon. We will try to provide backwards compatability -as much as we can but I have decided to ditch the docker daemon and write -compatable code from containerd.
IPV4 and IPV6 support: All the nodes can listen to both IPV4 and -IPV6 addresses. It can be noted that with IPV6 there are minor issues -detected in certain PC in terms of SSH into a docker container which is -mostly on the server side.
Hopping mechanism: Since it’s a p2p network we have a very simple -implementation that hops though servers and downloads it’s IP tables. -In our implementation. This contains about imformtaion of other servers -in the network. This way nodes can automatically learn parts of the -network. The current implementation uses 3 hops.
Possibility to run any docker container: To satisfy this the server -must already have the docker container and the must ensure that the -SSH username is ‘master’ and password is ‘password’ in creation of new -servers. It’s not secure but worksout for this version for now.
The test network will be avaliable for use from the beta release -which should come out on the 5th of july 2021. The network will -consist of 1 node which runs on a paid cloud server as I do not -keep my machines on 24/7. The node up will help to connect with -other nodes and the paid cloud server cannot be used to create -and remove containers.
https://github.com/Akilan1999/p2p-rendering-computation/releases/tag/v1.0.0-alpha
P2PRC is a great layer of abstraction. This means that in many cases it is not an end product but rather -a tool that customized as an end product. An example would be writing your own billing module to monetize -the computation power available. The generate module copies the current with the appropriate git histories -and keeps only the go files which would be useful to edit. To use the generate module the user will need -to have a go compiler present in his computer. Due to the introduction of this module there will 2 releases:
Generate.go:
-This file creates a local copy of P2PRC from where the CLI was called from.
-This go file also does various stuff like instruction of file should be ignored when copying and
-which of should not be. Now let’s understand this. Below is a sample code which does the following: //----------------------------------------------------------------
- // Action performed:
- // - Ensuring main.go file exists
- // - Skipping all .go files apart from the ones listed above
- // - Skipping .idea/ directory
- // - Skipping Makefile file
- //----------------------------------------------------------------
- Options.Skip = func(src string) (bool, error) {
- switch {
- case strings.HasSuffix(src, "main.go"):
- return false, nil
- case strings.HasSuffix(src, ".go"):
- return true, nil
- case strings.HasSuffix(src, ".idea"):
- return true, nil
- case strings.HasSuffix(src, "Makefile"):
- return true, nil
- default:
- return false, nil
- }
- }
-
- // Doing the copy
- err = copy.Copy("<P2PRC folder you want to copy from>", "<PATH to the directory>", Options)
-Unfortunately currently this will have to be manually edited in the Generate.go file. When using the generate
-module the user also creates their own Go module which is the modified version of P2PRC. This means
-if the 1 modified package is using another modified package then the appropriate import have to be modified
-in the file where the import is called:
Ex:
//Sample Project module name = Test
- //Package names:
- //- Test/Genius
- //- Test/GeGeGenuis
- //
- // When we call the generate function with the new project with the module name = MicDrop
- // The new package name would be:
- // - MicDrop/Genius
- // - MicDrop/GeGeGenuis
-
- // Test/Genius code depends on the package Test/GeGeGenuis
- import (
- "Test/GeGeGenuis"
- )
-
-// When we create a new module with the copy of the
-// existing project we need change:
-import (
- "MicDrop/GeGeGenuis"
-)
-To do this we have built functions which can modify import names in the Go file provided. -To customize the use case of your generate module you would need to manually add your own -imports which are supposed to be replaced and in which files they are supposed to be replaced -in.
// 1.0 - Test/Genius.go -> GeGeGenuis module
-// a is struct of type NewProject
- a.FileNameAST = "<path to project to copy from>/Test/Genius.go"
- // Get AST information of the file
- err := a.GetASTGoFile()
- if err != nil {
- return err
- }
- // Change the appropriate Go file
- err = a.ChangeImports("Test/GeGeGenuis", "MicDrop/GeGeGenuis")
- if err != nil {
- return err
- }
- // Writes the change to the appropriate file
- err = a.WriteGoAst()
- if err != nil {
- return err
- }
-Higher order of execution of Generate.go:
modifyGenerate.go:generate.go. To do we create an AST (i.e Abstract Syntax tree)
-from new file we want to change the imports in. AST create a tree structure of expression. To change the
-import we can just traverse to the appropriate expression and change the value of that expression in
-the case of modifying imports. This approach is more simple than using templates.p2prc --gen <project name> --mod <go module name>
-P2PRC would be in-charge to set to the ports to various TCP ports -opened. Due to this implementation the plugin being executed is -copied to the tmp directory with a unique UUID.
Command: ls /tmp
-output: Semantic <UUID>_<Plugin Name>
-2e6d76c4-0ed1-4b55-9385-79a58d4f0492_p2prc-vscode-browser
-7b631e08-62ee-4c1c-a2a4-c05857b9aa7d_p2prc-vscode-browser
-Once the copy of the plugin is added to the /tmp directory -the site.yml file inside the appropriate yaml is modified -with the appropriate ports assigned to the container.
---
-- hosts: all
- tasks:
- - name: start vscode code server
- shell: sh server.sh 0.0.0.0:{{index . 0}}
-Notice there is the following {{index . 0}}. {{index . 0}} does not belong to -Ansible but rather is a way to mention where to add the external free port -of the container. We use the golang template library -to parse and populate the site.yml with the appropriate open ports. An array of ints -which consists of open free ports are sent to the site.yml. 0 in {{index . 0}} refers -to the index in the int array passed on.
After the port is automatically it’s ready to run !
---
-- hosts: all
- tasks:
- - name: start vscode code server
- shell: sh server.sh 0.0.0.0:3313
-We focus here on escaping NAT for the project P2PRC. The intial -plan is to use a middle server with an IPV4 address to escape NAT. -The future plan would be to use a WebRTC approach to where we -use a middle server to intansiate a direct p2p connection -using UDP sockets with nodes behind NAT.
The server behind NAT would use a reverse proxy server with an IPV4 address -to be a possible way to communicate with the outside world.
Ex:
NAT
- |
-Server <--> Reverse Proxy server with <--> Clients
- | public IPV4
-We use the libaray known as frp. -“frp is A fast reverse proxy to help you expose a local server behind a NAT -or firewall to the internet.”
The server behind the NAT IPTable would be broadcasted through the reverse proxy. -The mapping would be done automatically though P2PRC because the reverse proxy -could have certain ports already taken.
We are introducting a new concept of detecting reverse proxies over P2PRC.
-We call this reverse_proxy_server.json and reverse_proxy_mapping.json.
-The reverse_proxy_server.json file is incharge of detecting all reverse
-proxy servers and the reverse_proxy_mapping.json is incharge of logging
-all the reverse proxy server mappings talking place.
{
- "reverse_proxy_servers": [
- {
- "Server_name": <server name>,
- "Address": <remote address>,
- "Latency": <latency>
- }, ... n
- ]
-}
-{
- "reverse_proxy_mappings": [
- {
- "Server_name": <server name>,
- "Address": <remote address>,
- "Type": <TCP or UDP>,
- "blind_port": <port no>
- }, ... n
- ]
-}
-The function for port allocation would need certain -modifications need to ensure that the port is not only free -on the server but also on the on reverse proxy server. -We are debate on this would occur as it requires -further reading on the inner depths of frp. -The idea scenario would be that the odds a 5 or 6 digit -taken is a low probability.
There would not be much change when a client looks -at it. This only difference is that the client -see’s the address of the proxy server.
Ex:
{
- "ip_address": [
- {
- "ipv4": "<reverse proxy address>",
- "ipv6": "",
- "latency": 0,
- "download": 0,
- "upload": 0,
- "serverport": "<server port no>"
- }
- ]
-}
-If the server is using a reverse proxy then the server -port no should be decided by P2PRC to ensure that there -is no scenario where the port is already taken.
We will be introducing a new set of Cli commands. -These cli commands would be incharge to starting -the reverse proxy or connecting to the reverse proxy -and various other function.
p2prc -s --reverse-proxy
-This will start the reverse -and autoamtically broadcast -as a reverse proxy as well.
p2prc -s --connect-reverse-proxy <proxy ip address>
-This will start p2prc as server -and automatically set the server port -and link it to the reverse proxy and -any connections would go through the -reverse proxy.
p2prc --view-rps or p2prc --view-reverse-proxy-servers
-p2prc --view-rpm or p2prc --view-reverse-proxy-mapping
-The plugin module is designed to ensure clients can execute instructions in a declarative manner across different -containers created. This means the user (i.e client) needs to write the instruction only once, and these instructions -can be executed across different nodes in a repetitive manner.
In the scenario of this project Ansibles will be used as the way the users can create these instructions.
The plugin module introduces a new path to the config file known as pluginpath. This path by defaults points to
-${P2PRC}/plugin/deploy. Any file/folder inside plugin/deploy is part of the .gitginore. Plugins are
-detected by folder names inside the plugin/deploy.
plugin
-|___ Deploy
- |___<plugin name>
- |___ site.yml
- |___ hosts
- |___ description.txt
- .
- .
- .
- n: n number of plugins possible
-The site file is also known as the Ansible playbook and is incharge of executing -instructions in a declarative manner. The below example specifies how to make one.
- hosts: all
-
- tasks:
- - name: <task name>
- <ansible task>
- debug:
- msg: <debug message>
-Read more about ansible tasks: https://docs.ansible.com/ansible/latest/user_guide/playbooks_intro.html#about-playbooks
hosts file is also known as the inventory file. This file consists of all the information required to connect to other -nodes to execute Ansible instructions. In this project this file needs to be set in a certain configuration because the -go code or binary will populate this file automatically with the appropriate information required to connect to local or -remote containers.
all:
- vars:
- ansible_python_interpreter: /usr/bin/python3 // Path to your python 3 interpreter
-main:
- hosts:
- host1:
- // Note: These values will be automatically overwritten
- // by the Go functions
- ansible_host: 0.0.0.0
- ansible_port: 39269
- ansible_user: master
- ansible_ssh_pass: password
- ansible_sudo_pass: password
-This is a simple text file used to describe what the module does. -When the client is looking at various commands via the ClI. -The description is displayed along-side the plugin name.
Ex: When the flag --ViewPlugins or --vp is called
{
- "PluginsDetected": [
- {
- "FolderName": "<name of the plugin>",
- "PluginDescription": "<description of the plugin>"
- }
- ]
-}
-RISC-V is just an open source ISA (Instruction Set Architecture). An ISA is the software interface for the hardware. A single ISA can -have many hardware implementations. In technical terms as ISA defines set of Instructions and how they behave such as:
Another important factor to understand is that RISC-V is a standard -and not an implementation. This means that the entire ISA is defined in a huge latex file which can be found on Github.
Repo link: https://github.com/riscv/riscv-isa-manual
The RISC-V is a well organized ISA and is divided into various categories and extensions in order to keep it as a modular design. -The RISC-V is maintained the non profit organization called RISC-V foundation.
In this section we look into how RISC-V is organised
RV32I, RV64I, RV128I
This is called as RISC-V 64 bit General Purpose
RV32I is a base ISA and the easiest to understand. -RV32I means it’s RISC-V 32 bit Integer ISA.
Registers: x0-x31
-(x0 is hardwired to 0)
-Each register is 32 bits which can be called as 1 word.
-Fig 1.0 Simplified schematics of RV32I
Now we will recall the basics and try to understand -how to read an instruction.
add rd,rs1,rs2
-
-Fig 1.1 Assembly instructions for RV32I
-Fig 1.2 Registers for RV32I
Implementing RISC-V System-on-Chip for Acceleration of Convolution Operation and Activation Function Based on FPGA (Field programmable gate arrays): FGPA are mostly for application specific integrated circuits. An example would be Intel using FGPA to -prototype new chips. The objective of the paper was to design -a RISC-V processor for specific tasks such as Convolution functions and activation functions. The result was that the -RISC-V processor was faster than CPU + co-processor mode and -used lesser than the CPU + GPU mode.
Towards deep learning using Tensorflow lite on RISC-V: This paper focuses on ISA extensions customized for -machine learning kernels. The software infrastructure implemented was optimized for neural network execution. -The following was integrated into Tensorflow lite. The -result was that instructions was reduced by 8X.
A compiler comparison in the RISC-V ecosystem: Comparing LLVM and GCC performance on RISC-V. LLVM and GCC -produce same binary size but both have different execution -times.