Forem: Bence Kotis

Is the pain worth the gain? Writing webapps in C (Benchmarks vs Flask and Nodejs)

Bence Kotis — Thu, 29 Oct 2020 02:49:34 +0000

I wanted to do a performance comparison between Facil(a web framework for C) against some more conventional tools, such as Flask(Gunicorn server) and Nodejs. Let's dive in!

How the benchmarking was done:

A simple webapp was made using each framework. These webapps embed the client's IP address in a page template and then serve it to the client.
The 3 webapps were tested under light, medium and heavy load for 5 minutes each, running on a 1GB single core virtual machine(on Digital Ocean)
They were evaluated on response time, CPU and memory consumption.
In all of the plots below, the average value by Facil is shown as a dotted blue line for easier comparison.

TLDR;

If you are developing a high load web application(over 1000 requests per second), writing it using Facil could definitely pay its dividends over time when it comes to resource consumption, response time(latency) and the variance of these two factors(they tend to stay more predictable, even under a sudden surge in load)
For light load applications, Facil might be overkill(did not provide significant benefits) unless you are developing for an embedded platform or you prefer to develop in C compared to other languages

Heavy load (~1100 requests per second)

Response Time

Facil has come out on top by far when it comes to latency under heavy load. Facil managed to:

Have less of a latency spike (it responded better to a sudden surge in load at the beginning of the test)
Have much less variance in response time (more reliable results)
Have a lesser average response time under heavy load

Resource Consumption

When it comes to resource consumption, Facil also managed to:

Have lesser resource consumption in both ram and CPU, especially compared to Flask
Have a lesser variance in resource consumption compared to other frameworks

Medium load (~400 requests/sec)

Response Time

Under medium load, Facil was:

still leading ahead of Flask in terms of response time, but Nodejs is catching up(Facil was arguably a tiny bit better though).
Facil still had a better response to sudden load in the beginning of the test than Nodejs

In terms of resource consumption, under medium load, Facil:

Is still significantly leading in terms of RAM consumption ahead of both Flask and Nodejs
Had less of a CPU spike under sudden load
Had less variance in CPU consumption compared to the other two candidates

Light load (~100 requests/sec)

Under light load, Facil:

Had seemingly no advantage in response time over the other frameworks

Facil had some minimal advantage in RAM consumption compared to other frameworks

Final notes

Obviously this was just a simple test, but it has shown that if you are expecting large loads, want to keep hosting as cheap as possible by minimizing resource consumption, or doing development for embedded platforms, a non-conventional framework like Facil might be worth looking into.

You can find the source code for the 3 webapps under:

wickdChromosome / simple_webapp_comparison

Repo for article comparing benchmarks for writing webapps in C, Flask, Nodejs

Spicy plots with matplotlib

Bence Kotis — Fri, 17 Jul 2020 19:45:56 +0000

The full code used in this article in the form of a Jupyter notebook can be found here.

1. Use Google Fonts!

Google Fonts has thousands of fonts you can download to make your plots look a bit more refined.

The easiest way to install new fonts if you are on Linux is using font-manager.

On Debian or Ubuntu, you can install font-manager by doing:

sudo apt install font-manager

Find your favorite font on Google Fonts.

My current favorite on there would have to be Roboto Condensed. Download and unzip your fonts, then add them(all the .tff files) inside font-manager by clicking the + button on the top left corner:

Now if you open up a Jupyter notebook, you should be able to list all the fonts available to Matplotlib by doing:

#clear the matplotlib font cache (this is important!!!)
!rm -fr ~/.cache/matplotlib

#originally from: http://jonathansoma.com/lede/data-studio/matplotlib/list-all-fonts-available-in-matplotlib-plus-samples/
import matplotlib.font_manager
from IPython.core.display import HTML

def make_html(fontname):
    return "<p>{font}: <span style='font-family:{font}; font-size: 24px;'>{font}</p>".format(font=fontname)

code = "\n".join([make_html(font) for font in sorted(set([f.name for f in matplotlib.font_manager.fontManager.ttflist]))])
HTML("<div style='column-count: 2;'>{}</div>".format(code))

After that, your new fonts should be ready for use by using the fontname attribute in most matplotlib objects, like plt.title:

2. Use gifs/images to add some personality to your plots

This plot looks about as boring as it gets.

Lets write some code to create an image/gif overlay for our plot:

def add_overlay(base_im, overlay_im, newsize, pos, outname='output.gif'):
    '''Adds a png or gif to your plot'''

    #open both images
    original_image = Image.open(base_im)
    animated_gif = Image.open(overlay_im)

    frames = [] #used to store output frames for gif

    #iterate over input gif
    for frame in ImageSequence.Iterator(animated_gif):

        #resize each frame
        frame = frame.resize(newsize) 
        #copy plot and paste gif frame on top
        original_image = original_image.copy()
        original_image.paste(frame, pos)
        frames.append(original_image)

    #you can change the duration variable to change gif speed
    frames[0].save(outname, save_all=True, append_images=frames[1:], duration=70,loop=0)

After adding some images, the plot is a lot more eye-catching!

The same code can be used to add animated gifs to your plot.

Gifs are a great way to annotate your plots and convey how you feel about your results:

Conclusion

I hope these tips gave you a bit of inspiration to spice up your plotting workflow. For the full code used in this article, refer to this Jupyter notebook.

3 easy ways to speed up your python code within minutes

Bence Kotis — Wed, 01 Jul 2020 22:29:21 +0000

I. Benchmark, benchmark, benchmark

Benchmarking sounds like a tedious process, but if you already have working code separated into functions, it can be as easy as adding a decorator to the function you are trying to profile.

First off, lets install line_profiler so that we can measure the time spent on each line of code in our function:

pip3 install line_profiler

This provides a decorator(profile) that you can use to benchmark any function in your code line by line. As an example, lets say that we have the following code:

#filename: test.py

@profile
def sum_of_lists(ls):
    '''Calculates the sum of an input list of lists'''

    s = 0
    for l in ls:
        for val in l:
            s += val

    return s


#create a list of lists
smallrange = list(range(10000))
inlist = [smallrange, smallrange, smallrange, smallrange]

#now sum them
list_sum = sum_of_lists(inlist)

print(list_sum)

This will profile the sum_of_lists function when called - notice the profile decorator above the function definition.

Now we can profile our code by doing:

python3 -m line_profiler test.py

Which gives us:

The 5th column shows the percentage of the runtime spent on each line - this will point you to the section of your code that needs optimization the most, as this is where most of the runtime is spent.

Keep in mind that this benchmarking library has significant overhead, but it's perfect for finding weak points in your code and replacing them with something more efficient.

For running line_profiler inside Jupyter notebooks, check out the %%lprun magic command.

2. Compile your Python modules using Cython

If you don't want to modify your project at all but still want some performance gains for free, Cython is your friend.

Although Cython is not a general purpose python to C compiler, Cython lets you compile your python modules into shared object files(.so), which can be loaded by your main python script.

For this, you will need to have Cython, as well as a C compiler installed on your machine:

pip3 install cython

If you are on a Debian, you can download GCC by doing:

sudo apt install gcc

Lets separate the starting example code into 2 files, named test_cython.py and test_module.pyx:

#filename: test_module.pyx

def sum_of_lists(ls):
    '''Calculates the sum of an input list of lists'''

    s = 0
    for l in ls:
        for val in l:
            s += val

    return s

Our main file has to import this function from the test_module.pyx file:

#filename: test_cython.py

from test_module import *

#create a list of lists
smallrange = list(range(10000))
inlist = [smallrange,smallrange,smallrange,smallrange]

#now sum them
list_sum = sum_of_lists(inlist)

print(list_sum)

Now lets define a setup.py file for compiling our module using Cython:

#filename: setup.py

from setuptools import setup
from Cython.Build import cythonize

setup(
    ext_modules = cythonize("test_module.pyx")
)

Finally, its time to compile our module:

python3 setup.py build_ext --inplace

Now lets see how much better this version does compared to the original by timing them 1000 times:

In this case Cython nets us an almost 2X speed-up compared to the original - but this will vary depending on the type of code you are trying to optimize.

If you are looking to take advantage of Cython inside Jupyter notebooks, there is a %%Cython magic available which lets you compile your functions with minimal hassle.

3. Avoid loops when possible

In many cases using operations like map, list comprehensions or numpy.vectorize(usually the fastest) in python instead of loops can give you a significant performance boost without much work, as these operations are heavily optimized internally. Lets modify our previous example a bit by replacing the nested loops with map and sum:

#filename: test_map.py

def sum_of_lists_map(ls):
    '''Calculates the sum of an input list of lists'''

    return(sum(list(map(sum,ls))))


#create a list of lists
smallrange = list(range(10000))
inlist = [smallrange,smallrange,smallrange,smallrange]

#now sum them
list_sum = sum_of_lists_map(inlist)

print(list_sum)

Lets see how the new map version does compared to the original by timing them 1000 times:

The map version is over 6X faster than the original!

Conclusion

These were 3 easy to implement tips to net you some extra performance - for more information about line_profiler and Cython in Jupyter, you can check out the %%lprun and %%cython cell magics.