Adam Hawley

How Intel Server CPUs Save Power - Intro to C-states

Sun, 10 Sep 2023 11:28:57 +0300

Note: this post describes how C-states work on Intel server CPUs. C-states are often similar on alternative platforms but the specifics of each state differ. However, the basic concept of using C-states for power management is common to all platforms, including client systems.

What are C-states?

C-states represent different power states for CPU cores, each state consumes different amounts of power and has slightly different behaviour. They are used to save energy while the CPU is powered but idle.

As a human analogy, think of C-states as different stages of relaxation; going from a quick sit-down all the way to a deep meditation.

As with humans, the deeper the state a CPU is in, the longer it will take to resume working/respond to interruptions. This is an important aspect of CPU power management; balancing power savings from entering deeper states without increasing the time it takes to continue operating.

Differences between “hardware” and “software” C-states

It is important to be aware that there are two types of C-state and both are often used in isolation and simply called “C-states”.

Software C-states are commonly also referred to as “Requested C-states” or “Logical C-states”. This is because these are the C-states which can be requested by the operating system. While hardware C-states reflect the actual state of a CPU. Notation varies slightly between hardware and software C-states but understanding how they connect is usually intuitive.

For example, the OS can request that the CPU goes into the hardware state “CC1”, by referencing the software state “C1”.

How are C-states used to save power?

When the operating system has no runnable tasks, it can maximise on the opportunity to save power. It first estimates which software C-state will be the most suitable to request based on a number of factors such as how long it thinks the system will be idle for. Then it uses the mwait instruction to hint and request that C-state to the CPU. It is then up to the processor to determine exactly which hardware C-state it will enter.

What are the different C-states?

Going from “shallowest” to “deepest” (i.e. lowest to highest power saving), here are examples of commonly used hardware C-states:

This list is not exhaustive of all C-states and many platforms support many other hardware C-states. However, those listed below are extremely widely supported and used in production systems working today.

CC0 - The busy state, indicates that the CPU is currently operating.
CC1 - The CPU begins “core clock gating”. In CC1, the core has stopped executing but the state is preserved. This means that to return to normal operation, the core just has to stop core gating.
CC1e - Known as “Enhanced C1”. In addition to the clock gaiting involved in CC1, there is also a suggestion to drop the core voltage. This means that C1e has a similar wake-up latency to C1 but will operate at a slightly lower frequency after waking up, while the voltage is restored. Note: the reason it is only a hint, is that the CPU will generally only reduce the voltage if every core has entered C1e.
CC6 - Rather than clock gating, in CC6, the CPU begins “power gating” which means that the core voltage will be reduced to 0V. Cores in CC6 can take up to 10 times longer to wake from idle than the previously-mentioned C-states. This is because when the core reduces the voltage to 0V, it has to flush caches and other state-saving components. This means that the state of the core has to be saved elsewhere. Therefore, when the core is awoken, it will have to restore its operating state from nothing. This process of restoring the state does not apply to any of the previous C-states.

All of the C-states above are core C-states, which means that they affect the power consumption at a core level. However, there are C-states which represent a power state of larger scopes such as at the package level (e.g. PC6 - package C6).

Wake Latency

As mentioned above, going to deeper states means saving power. But this comes at a cost. That cost is called “Wake Latency”. Wake latency is the time it takes for the CPU to wake from a given C-state and continue operating.

To measure wake latency, at Intel, I work on a free and open-source tool walled ‘wult’ - Wake Up Latency Tracer. ‘wult’ tests wake latencies of CPUs with the following process:

Set a timer in the future - the CPU “alarm clock”.
Tell the CPU to sleep.
When the timer expires, trigger an interrupt which wakes the CPU.
As soon as the CPU is awake, read the current time and calculate the difference between the timer triggering and the current time. That’s the wake latency!

For more information, the wult documentation describes in detail how the process works and the selection of methods that can be used to implement the method outlined above.

How can I modify C-states on Linux?

Another free and open-source tool I have contributed to is called ‘pepc’ - Power, Energy & Performance Configurator. On Linux, this tool can be used to easily enable and disable C-states through a CLI.

Connecting to Firestore - Link-Sharing Site Part 3

Tue, 26 Apr 2022 00:00:00 +0000

New to this series? Start here!

Introduction

Thanks for taking the time to join me on my journey to create a new link-sharing site. In the last post I talked about how I initialised Firebase. Today I get to talk about how I hooked the web app up to work with Firebase’s offerings. In particular I will cover how I connected Firestore and gave users a way to submit and view links stored on it.

Handling Authentication

In the previous post, I also described how I used the Firebase SDK function createUserWithEmailAndPassword() to connect a sign-up form to Firebase Authentication.

Even after signing up, I presumed that I would first have to create the account and then call a sign in function separately. However the Firebase SDK makes it easier than that! If an account is successfully created then the user is automatically signed in.

Web Component Redirects

So, a user has created an account and been signed in. At this point, most sites I know redirect the user back to their previous page or another specific page. To simplify things, I opted to redirect the user to the ‘browse’ page whenever they have signed in. This page is the page where users can ‘browse’ all of the recently added links, it also acts as the home page (see below).

Initially, createAccount() looked like this:

createAccount(email, password) {
  const auth = getAuth();
  createUserWithEmailAndPassword(auth, email, password)
  .then((userCredential) => {
      const user = userCredential.user;
  })
}

At first, I called createAccount() and then immediately redirected the user to a new page. Without waiting for the response to createUserWithEmailAndPassword(). I quickly realised this was an issue, whether the account creation was successful or not was not important. If a user clicked the ‘submit’ button in the sign-up form, they were getting redirected, authenticated or not.

However, if an account is not created due to an error such as an invalid email or password being used, then the user interface should give the user an opportunity to amend their form entries. To get around this, I wrapped my createAccount() logic in a Promise:

createAccount(email, password) {
  return new Promise ((resolve, reject) => {
    const auth = getAuth()
    createUserWithEmailAndPassword(auth, email, password)
    .then((userCredential) => {
        this.user = userCredential.user;
        resolve()
    })
  })
}

As a relative-newcomer to JavaScript, I am still trying to get to grips with everything related to async, await, Promise etc. So for fellow newcomers, I recently published a guide on getting started with JavaScript Promises.

Signing In

Users could create accounts, hurrah! But they couldn’t yet sign in without making a new account every time. Doesn’t sound too user friendly to me…

Keeping it as simple as possible, I put together a sign in page which looked exactly the same as the sign up page. The only difference being what went on when the user hit ‘submit’. My signIn() method is almost identical to createAccount(). The difference being that signIn() uses signInWithEmailAndPassword() rather than the aforementioned createUserWithEmailAndPassword().

Working Sign-in Page

Now it’s time to celebrate! Working authentication hooked up to Firestore. Users can now create accounts on the site and sign-in later.

Firestore

Adding Links

Onto the content of the site. We have already seen how users will view links on the browse page in the web component redirects section and in part 1 of the series, I showed how I created a page for submitting links but mentioned that the submit button did nothing at all. Time for that to change!

I started by creating an event handler submitLink to handle when the submit button in the form is pressed:

get _form () {
  return this.renderRoot.querySelector('#submit-form')
}

async submitLink (e) {
  let userTitle = this._form.querySelector('#title-input').value
  let userLink = this._form.querySelector('#link-input').value
  const db = getFirestore(this.app);
  let col = collection(db, 'links')
  await addDoc(col, {
    link: userLink,
    title: userTitle
  })

  const event = new CustomEvent('submitted-link')
  this.dispatchEvent(event)
}

I also amended the submit button in the template to use the new submitLink handler:

<sl-button @click=${this.submitLink}>Submit</sl-button>

On the Firebase side of things, I start by using getFirestore(). I pass this.app to getFirestore() where this.app is a property passed to the web component equal to the output of initializeApp(). The aim of this first line is to initialise a variable with access to the database.

Then I define col, a variable with access to the specific collection within the database:

let col = collection(db, 'links')

The final step is to add the document containing the link to the collection:

await addDoc(col, {
  link: userLink,
  title: userTitle
})

If this operation is successful then we have added the link to the database! Following this, I use the same strategy as described earlier to redirect the user to a new page by dispatching a custom event.

Reading Links

Luckily reading from Firestore is very similar to writing to it. Here are the lines I use to get all of the available links from the links collection:

const db = getFirestore(this.app)
let col = collection(db, 'links')
const querySnapshot = await getDocs(col)
querySnapshot.forEach((doc) => {
  this.linkBoxes.push(doc.data())
})

The first two lines are exactly the same as writing and follow exactly what I described in the previous part. Things change a little in the third line.

A querySnapshot contains the results of a query. By using getDocs() on the whole collection col, I am asking to return all of the documents in the collection into the variable querySnapshot.

Once the query is resolved, I loop through each document and add them to the list of links shown on the browse page.

Note: to access the contents of each document you have to iterate through each and call its .data() method.

That’s all there is to it! Link submission works and now the home page is populated using links properly submitted by the user(s).

Conclusion

In this update I have discussed:

I sincerely hope you have enjoyed this update. If you would like to hear when I publish more updates, sign up to the mailing list below or follow me on Twitter.

Get Started with JavaScript Promises (in Under 2 Minutes)

Tue, 12 Apr 2022 00:00:00 +0000

Intro

Welcome to an extremely brief introduction to JavaScript Promises. After getting to grips with Promises myself I thought I would share the essentials that I needed to put them into practice.

Basics of JS Promises

Promises can be defined with the following recipe:

function function1 () {
  return new Promise ((resolve, reject) => {
    try {
      doSomeStuff()
      resolve()
    } catch (err) {
      reject(err) 
    }
  })
}

resolve() should be called if the operation associated with the Promise has been successful. reject() should be called if the Promise could not be resolved, maybe there was some sort of problem when trying to perform the associated operation.

The caller function then has the option to asynchronously wait for the Promise to resolve using await or the then() method of Promises. To use await, declare the entire function as asynchronous using the async keyword. Here are examples of both:

async function callerFunc1() {
  // Use 'await'
  await function1()
}
  
function callerFunc2() {
  // Use '.then()'
  function1().then(() => {
    doSomethingAfterwards() 
  })
}

Two extra things about Promise.then(). Firstly, we can chain .then() statements together to make something that operates like so:

function callerFunc3() {
  function1.then(() => {
    console.log('First thing finished')
  }).then(() => {
    console.log('Second thing finished')
  })
}

Secondly, then() can actually take two arguments: one in case the Promise resolves and another to handle the case when the Promise rejects.

function callerFunc4() {
  function1.then(() => {
    console.log('Everything went to plan!')
  }, () => {
    console.log('The Promise rejected :(')
  })
}

If you want to see these examples in action, check out this StackBlitz

Conclusion

Hopefully you found this helpful, to get updates as soon as I release helpful guides such as this follow me on Twitter or sign up to my mailing list below!

Initialising a Firebase App - Link-Sharing Site Part 2

Mon, 14 Mar 2022 00:00:00 +0000

New to this series? Start here!

Introduction

Welcome to the latest update in the “Creating a Link-Sharing Website” series where I try to build a StackExchange and HackerNews crossover. Before this update, I had a couple of working UI elements and (hopefully) a cool idea. See my last post to see exactly how I got started building out the first core UI elements.

If you want to jump straight to reading how I got started with Firebase, click here.

I concluded the last post by discussing how my top priority was to consider database solutions. This is because, at that point, a user could interact with the UI and ‘submit’ links to the website but with no real effect. The UI would simply gobble up the form entries and do nothing with them. Content generation that doesn’t involve generating content? Sounds pretty redundant to me.

Deciding on a Storage Solution

So I needed a way to store the links users would be uploading to the website. Naturally, I started to consider a number of database solutions I have used in the past.

MongoDB: a document-based NoSQL database that I have extensive prior experience with.
Firebase: actually a whole suite of services provided by Google. It includes, but is not limited to, two different database offerings, an authentication service and hosting.
ElasticSearch: in the past, I have worked with ElasticSearch as a database for storing text data. Because of this, I know that it has extremely powerful search and query capabilities.

When evaluating the different choices I had to think about what I was going to be storing. URLs and the title’s of the pages. Text. The basis of the site is for people to share website links. If I want people to be able to share and view them, I have to store them somewhere. Specifically, my plan is to store simple objects in the form:

{
  url: "https://adamjhawley.com/post/2022-02-07-using-git-rebase-to-perfect-commits/",
  title: "Using 'git rebase' to Perfect Commits"
}

Even though MongoDB would definitely be up to the job if I had opted to select it, I ultimately disregarded it. It was going to do exactly what it said on the tin; no more, no less. It would serve as a document-based database with developer-friendly APIs. So this would have definitely been my choice if another wasn’t so tempting…

Despite the fact that I had experience using ElasticSearch to quickly navigate mountains of text data, I had an important realisation. I was not going to be doing any complicated queries. So what’s the point? I had to stop myself from dodging Occam’s razor and consider something else.

It is important to me to keep the website true to itself. I know from experience that I, like many other developers, am easily distracted by the thought of adding cool new features, insights and analytics to websites long before they are necessary.

Now onto Firebase. As I mentioned earlier, Firebase is rather a whole suite of services provided by Google. Apart from a storage solution, Firebase offers hosting, authentication and several other services.

Initially it might appear as if I am going against what I just said with regards to keeping things as simple as possible. However, there is a key difference between the extra features of Elasticsearch and the other services offered by Firebase.

Solutions for hosting and authentication are things I would need to even get the base functionality of the site off the ground. For example, without a way to host the site, there is no way for users to reach it. Of course, I could handle this myself but that would involve taking on a considerably large amount of work. Remember, at this point, I am focusing on an MVP. Furthermore, I am considering making the website open source as a template for other developers to use. By using Firebase it means that it would be much easier for someone else to pick up the project. All they need is a Google account!

Firebase

Initialising a Firebase Project

So how did I actually get started? The first thing I did was turn to the Firebase web documentation on getting started. From there I followed the following steps:

Created a Firebase project using the Firebase console
Installed the Firebase CLI tools: npm install -g firebase-tools
Logged in using Firebase CLI: firebase login
Initialised the project as a Firebase app: firebase init with the following configuration:

firebase init dialogue.

Note: during the firebase init dialogue you might get an error similar to the following. Don’t panic. For some reason, Google requires that users create the Firestore instance in the UI before it can be accessed with CLI tools. Simply follow the URL in the error and create a Firebase instance in your browser.

Error: It looks like you haven't used Cloud Firestore in this project before. Go
to https://console.firebase.google.com/project/<PROJECT-ID>/firestore to
create your Cloud Firestore database.

After this, Firebase CLI automatically generates a handful of config files which it will use for deploying to Firebase, configuring storage etc.

In order to submit links to Firestore (the Firebase storage service I have opted for), it requires a working authentication system. By default, Firestore does not allow for unrestricted access to the database. Besides, I plan to limit users to only be able to post links if they are signed in to an account. So authentication is a necessary step. So I decided it was best to start with it rather than working around it and then having to come back and rework in future.

Problems with FirebaseUI

During the process of setting up the application to use Firebase authentication, I found helpful documentation on how to use a pre-built UI for authentication which apparently allows for:

Multiple authentication providers (email/password, Google, Github etc.)

Account linking

Customisation

One-tap sign-up and automatic sign-in

Localised UI

This all sounded great. I tried to integrate this into the application but ran into an issue trying to import the package.

In the project, I use ES module imports. That is, imports in the format:

import x from 'npm-module/app';

For some reason, this doesn’t seem to be supported by the FirebaseUI. This GitHub issue has been open since 2020 with no clear progress seemingly made.

After reading through the issue thread I decided to abandon using the FirebaseUI and build my own authentication UI.

Creating an Sign-Up Page

Link-Sharer sign-up page.

Using shoelace.style’s helpful <sl-input> elements with built-in input validation for emails, I put together a sign-up page with a component with the following render functions:


get _form () {
  return this.renderRoot.querySelector('#signupform')
}
  
handleSubmit (event) {
  let email = this._form.querySelector('#email').value
  let password = this._form.querySelector('#password').value
  this.createAccount(email, password)
  this.signIn(email, password)
}

render() {
  return html`
      <div id="signupform">
          <sl-input id="email" label="Email" type="email" placeholder="Enter email here" clearable></sl-input>
          <sl-input id="password" label="Password" type="password" toggle-password placeholder="Enter password here"></sl-input>
          <br>
          <sl-button @click=${this.handleSubmit}>Submit</sl-button>
      </div>
  `;
}

Where createAccount() and signIn() use the Firebase authentication SDK. For example:

createAccount(email, password) {
  const auth = getAuth();
  createUserWithEmailAndPassword(auth, email, password)
  .then((userCredential) => {
      const user = userCredential.user;
  })
}

A couple of interesting things here:

I linked handleSubmit() to the click event of the <sl-button> element using @click=${this.handleSubmit}. For more information, see the lit documentation on adding event listeners in the element template.
_form acts as a way to make the child <div> element accessible throughout the component and to parent components. This technique is also documented in the lit documentation. See accessing nodes in the shadow DOM.

Conclusion

At the end of this update I have a working way for users to sign up! I had hoped to have a working storage solution by this point but I am happy with the progress I have made. I think the time I have invested into setting up Firebase will pay dividends in future when it comes to integrating with other services.

Only time will tell! Make sure you sign up to my mailing list below to find out!

Creating a Link-Sharing Site Part 1

Fri, 04 Mar 2022 00:00:00 +0000

Introduction

Welcome to the first update on my journey to creating a link-sharing site. If you are interested in what I am doing and why I am doing it check out the introduction to the series. And if you want to get notified when I post new updates, follow me on Twitter or sign up to my mailing list.

I have prioritised getting something functional. This means that I haven’t exactly created anything beautiful yet. But I’m sure that will be very obvious.

Building the Basics

I broke down my requirements based on the pages and functionality I needed to create to get an MVP (minimum viable product) up and running.

A Page for Consuming

Link-sharing websites are, simply put, a platform for facilitating content consumption. That is, the ‘content creation’ side of this website is limited to a user providing a link and a title. At least for the time being… Furthermore, I expect the majority of users to spend much more time consuming content rather than producing.

Therefore, I need a way for users to find content to consume! This page will probably act as the home page for the site.

My current intention is for this page to simply contain a list of cards where each one contains just the title of the link.

Figure 1: Screenshot of my ‘browsing’ page

A Page for Producing

Then again, what’s the point in a page for consuming content if there is no content to be consumed! Sounds like I can’t get away with not building a page for submitting links to the site.

So, as I said, I went ahead and made it as minimal as possible.

Figure 2: Screenshot of my ‘submit’ page

Now it’s worth noting that for the time being, that ‘Submit’ button sends the link nowhere. My plan is to hook this up to a database which will contain all of the links on the site.

Conclusion

That’s all I have for this update. My main priority in upcoming updates will be hooking up the site to use a persistent database to store the links. It has been great fun getting started with this project and I am very excited to see where it can go!

I know that I am new to the concept of ‘sharing your work’ but I know consistency is key so stay tuned for another post coming soon!

Creating a Link-Sharing Site Part 0

Wed, 16 Feb 2022 00:00:00 +0000

Introduction

Welcome to a new series of blog posts. In this series I will be sharing my progress on a new project. What’s the new project? I want to create a link-sharing site similar to HackerNews but with the flexibility of StackExchange. Read on for more details.

Motivation - Why am I doing this?

As an avid reader of HackerNews one day I started to wonder if this kind of site exists in other domains. I knew that aggregators were popular in areas like finding new music but these tend to be more complex.

The thing I love about HackerNews is the organic growth of different links. When a link is shared on the site it is not surrounded by some long description or backstory. Just the title of the page. This means that the quality of the link is evaluated by readers based on the content rather than how well the poster is able to dress up the page with a misleading or exaggerating description.

As a developer, I also spend a lot of time on another site, StackOverflow or more generally, StackExchange. One interesting thing I find about StackExchange is the way that it has taken a concept which works in separate domains and implemented it across them separately. For example, as well as StackOverflow for programming, there is also english.stackexchange.com and mathematics.stackexchange.com for English and maths respectively. See a full list here: https://stackexchange.com/sites.

Considering these two sites I spend an awful lot of time on, I thought I would try to create a network of link sharing sites across different domains.

Showing My Work

Recently, I finished reading ‘Show Your Work!’ by Austin Kleon (and I highly recommend it)! To complement this, I recently listened to a great Indie Hackers podcast with Josh Pigford. Both of these inspired me to get into the habit of sharing my work. My blog itself is still in its infancy and I am trying to build up a habit of posting more regularly both as a good incentive to publicise work I produce and to track my learning with time.

Because of this I plan to blog my progress on this project and will be open to any feedback. If you want to keep updated with my progress, I strongly recommend signing up to my mailing list here.

Technology - How am I going to build this thing?

I have recently been picking up some experience using lit and have found that it provides a very quick and easy way to get going with web components. This is about all the thinking I wanted to do at this point. Too often I get bogged down planning and deciding on frameworks, languages etc. This time I wouldn’t let that happen. For better or for worse…

One thing I had heard of but not had the chance to use was the Lit element JavaScript project template. So this is going to act as the baseline for the project.

Here’s the first element I created which is incredibly basic. LinkBox refers to a box or card containing the link someone has shared.

import {LitElement, html} from 'lit';

/**
 * A small box containing a link and a title.
 */
export class LinkBox extends LitElement {

  static get properties() {
    return {
      /**
       * The title of the link.
       * @type {string}
       */
      name: {type: String},

      /**
       * The link itself.
       * @type {string}
       */
      link: {type: String},
    };
  }

  constructor() {
    super();
  }

  render() {
    return html`
      <a href=${this.link}><sl-button>${this.name}</sl-button></a>
    `;
  }
}

window.customElements.define('ls-link-box', LinkBox);

Keep in Touch

For now, this is where I am. I aim to post roughly once a week with updates on my progress. I hope you enjoyed reading and wish me luck! As mentioned earlier, if you want to get updates straight to your inbox, consider joining my mailing list below.

Happy hacking!

Using 'git rebase' to Perfect Commits

Mon, 07 Feb 2022 00:00:00 +0000

I have long tried to get into the good habit of committing as I develop. However, I often fell into the same scenario. On commit №4, I would realise that I should have worked something differently in commit №2.

Naively, my old approach was a combination of adding extra re-work commits and different forms of git reset. git rebase to the rescue!

The git rebase -i command was everything I believed had to be part of git but didn’t know of. The -i flag is the ‘interactive’ mode of git rebase. Which allows you to choose which commits you want to rebase.

Let’s have a look at an example to illustrate:

Figure 1: git log output before correcting my mistake

At this point I made a mistake a couple of commits ago and have even made further changes to some of the bad code I have written as part of future commits.

To go back in time, I use git rebase -i <COMMIT_ID>. Where <COMMIT_ID> is the commit id of a commit BEFORE my mistake.

Figure 2: git rebase -i

As shown in the helpful comments, there are many commands I can use for each commit and each one is explained. The commands I use most-frequently are ‘edit’ and ‘reword’ (‘reword’ is for the times when you have a typo in your commit message).

Here we can change pick to e or edit next to our bad commit before saving and closing the file.

Then I can go in and change my mistake. Once the changes are made, I can git commit --amend to fix the commit itself.

Once my initial mistakes have been corrected and git knows about the fixes I can use git rebase --continue. git will now try to apply my old commits (№3 & №4) on top of my fixes.

If there are any conflicts git will let you know. These happen in this case if your fix for the broken code replaced some of the code that you changed in later, good commits.

You should solve the conflicts so that the code is as you would want it at that commit. Importantly, you should stop before using git commit --amend here. git stopped to let you shape the commit in the way you want it and did not apply it yet. This means that to save this rework in the same commit, you should just go straight to git rebase --continue where git will ask you to confirm/edit the commit message.

Figure 3: git log output as if nothing was ever any different…

And there we have it! A clean git history with useful commits. Learning git rebase has truly given me a greater confidence using git and helped increase both my productivity and the quality of my work. I hope this you have managed to learn something too and thanks for reading this far!

Mastering ‘git’ with ‘git rebase’

Fri, 04 Feb 2022 00:00:00 +0000

Introduction

Recently, I started a new job. I sat down, checked out some repos, and cracked on with some work. When I was ready to commit my first changes, I typed git log to see how my new colleagues like to format their commits… No merge commits. A handful of devs all working on one branch simultaneously? What kind of elegant version control choreography had to be involved? I knew something was up…

Figure 1: What I was used to (a typical git-tree using git merge)

Figure 2: What I saw (the same git-tree using git rebase)

The answer? One command: git rebase.

What does ‘git rebase’ actually do?

If we imagine the scenario below:

Starting on grey-branch and running git checkout -b blue-branch creates the new branch blue-branch.
Commit two sets of changes with git commit
Then, a teammate pushes a couple of commits to grey-branch while your changes are still in review or you haven’t had time to merge.
We switch back to grey-branch and pull the changes our teammate added.

Figure 3: On the blue branch before ‘git rebase’

At this point, I was used to using git merge where I would solve any conflicts and create a merge commit, making the tree look like this:

Figure 4: Merging the two sets of changes with a merge

However, instead of using git merge , this is where git rebase comes in. If I am on blue-branch in figure 3 and I use git rebase grey-branch, magic happens:

Figure 5: Merging the two sets of changes with git rebase grey-branch

Isn’t that so amazing? My commits have now been ‘rebased’ on top of the commits in grey-branch .

But the magic doesn’t end there. Once I use git push blue-branch:grey-branch I get this beauty:

Figure 6: git elegance

So satisfying… All the changes with their relevant commit info but discarding branch history and those (now) pointless merge commits!

GraDiAn - the Grammatical Distribution Analyser

Mon, 28 Jun 2021 00:00:00 +0000

Introduction

The Grammatical Distribution Analyser (GraDiAn) is a Python library for analysing grammatical distributions; particularly with the aim of analysing NLP datasets. The library was originally created as part of my Bachelor’s degree at the University of York. Drift in grammatical distribution is often disregarded. The intention of the project was to analyse state of the art NLP datasets for undocumented grammatical distribution drift. Following the detection of such drift, the next stage would be to investigate the impact on machine learning models which such drift can cause.

See the original report here

For the purposes of the report and GraDiAn, grammatical distribution is defined as a measure of frequencies of various grammatical properties over of a text or series of texts. One potential use for grammatical distribution could be outlining a particular author’s writing style. Drift in grammatical distribution represents the idea that two datasets possess a statistically different grammatical distribution to each other. One example of this effect is that machine learning datasets and benchmarks often contain multiple splits, importantly a ‘train’ split which the model learns from and a ‘test’ split which the model is evaluated against.

Data Types

SentTree

The first of the two abstract data types which GraDiAn provides is the SentTree structure. The SentTree class allows a user to categorise sentences based on parse-trees and the appearances of different linguistic properties of tokens on that tree. For example, where a standard parse-tree may just display the tokens with the syntactic dependencies shown between elements; the SentTree means that the tree could be expanded to include other attributes such as part-of-speech (POS) tags and sentiment.

Syntactic Dependency Counter (SDC)

The Syntactic Dependency Counter is a much simpler structure in comparison to the SentTree. The inspiration for the SDC class was a severe contrast to popular word-embedding techniques. Where traditional word-embedding techniques discard explicit grammatical properties of the text, the SDC reduces text down to just its syntactic dependencies.

Example Usage

In the report mentioned above, both SentTrees and SDCs were used to represent attributes of different data points in state of the art NLP datasets. Each attribute was then evaluated for distribution drift between train and test splits. Further work could include investigating the effect this drift can have on the performance of machine learning models.

TicTacGo - An Intro to Golang

Sat, 26 Jun 2021 00:00:00 +0000

Introduction

I am a true beginner to the Go Programming Language and to solidify some of the basics I have acquired I set out on creating a naughts and crosses (tic-tac-toe) server as an introductory project. You can find the project on my Github here.

Board

Board is the struct I created to contain the current board state, the grid but more accurately the state contains the 9 cells in the grid and their contents. At a given point, I cell on the grid can either contain nothing, “O” or “X”, where the latter two represent a naught and a cross respectively. The struct contains only one attribute: Squares, of type [9]string. However, the Board struct has several related methods:

DrawBoard() string :: returns a string which contains the HTML representation of the board.
Reset() :: resets the board to an empty state.
CheckLegal(i int) bool :: checks if a given move is legal in the current state (i.e. if the move correlates to an actual cell in the grid and that cell is empty).
CheckWin(x string) bool :: where x should be “O” or “X”, checks to see if the given player is in a winning state.

The API

The net/http package (see docs here) provides a very convenient way of creating an API. Creating the endpoints is as simple as writing a handler function for the endpoint and then assigning that function to an endpoint. Then serve the API using the http.ListenAndServe function. See below for a bare-bones but complete example of a net/http API.

// Example net/http API
package main

import (
    "fmt"
    "log"
    "net/http"
)

func handler(w http.ResponseWriter, r *http.Request) {
    fmt.Fprint(w, "Here is a response!")
}

func main(){
    http.HandleFunc("/", handler)
    log.Fatal(http.ListenAndServe("localhost:8000", nil))
}

In TicTacGo, I use the API to register moves made by players. Specifically I have use a handler on the root endpoint / called makeMove. makeMove retrieves the player’s move from the path using r.URL.Path where r is passed to the handler function as an *http.Request. This is an impractical way to accept URL arguments and is far from standard but it is also not a concern for the tiny scope of this project. makeMove follows the following steps:

Accesses player’s move from path.
Checks the move is legal (if it isn’t no move is made and the input is ignored).
Makes the move by updating the Squares attribute of the Board struct with the appropriate character (“O” or “X”).
Checks for a win condition; if there a player has won than it sends a message to say so before resetting the Board with Reset(); else it waits for the next move.

By using the URL as a way for the player to make moves it allows me to embed buttons within the HTML representation of the board. This means that when the player clicks on the top-right cell on the board, the server will register their move with that cell.

TicTacGo Board HTML Screenshot

About

Sun, 07 Mar 2021 00:00:00 +0000

About Me

I am a first-class Computer Science graduate from the University of York working as a Software Engineer in the Linux Driver Department at Intel. The aim of this blog is a place where I can share the new things I learn/develop so that it might be that bit smoother for others after me!

Contact Me

Feel free to connect with me on any of the below:

Work Experience

Company	Role	Duration
Intel Corporation	Software Engineer	October 2021 – Present
Versed AI	Software Engineering Intern	November 2020 – September 2021
Amadeus IT Services UK	Software Developer Intern	July 2019 – July 2020

Donate

I have specifically chosen to host this blog in this way to avoid platforms which hide information behind paywalls. If you would like to support the blog with a donation then please consider buying me a coffee or by donating crypto.

Monero

87Z6Nw2Xa5bPM5ezuNssC8iEXeuCf5YPL711apDsGpdh51p8PWp3kAqRmRFW5GvdpHGf6B1vpqmSRPwGLWyhWdvS3ggvo4X

Creating a Perceptron in PyTorch Lightning

Sat, 13 Feb 2021 00:00:00 +0000

Introduction

In the grand-scheme of things, I am relatively new to ML and particularly neural networks. Like all good nn students that have come before me, I started by learning about a single perceptron. The perceptron is the most basic of neural network components. A perceptron accepts an input of size $n$ and has $n + 1$ weights, where the extra weight is to handle a bias (think of the bias as a permanent input of value $1*weight_{bias}$, or if you prefer to think visually, the bias represents $c$ in the $y=mx + c$ rule).

PyTorch Lightning

PyTorch Lightning is a lightweight wrapper around PyTorch which aims to make PyTorch code easier to read, more concise and quicker to write. If you are already with familiar with PyTorch but not PyTorch Lightning then you will be pleasantly surprised by its simplicity and if you are not familiar with PyTorch then you should find PyTorch Lightning code easier to pick up and understand for the first time.

Code

My aim was to create as simple an example as possible. For this reason, I settled on creating a perceptron with one input-weight pair. Its purpose: to double the input.

To start, here are some of the imports I will be using:

import torch
from torch import nn
from torch.utils.data import DataLoader, TensorDataset
import pytorch_lightning as pl
from pytorch_lightning import loggers as pl_loggers

Creating the Dataset

The perceptron needs to learn from data, hence the need to create a dataset. On the first line, I define train_size. This variable describes the amount of data we want to train out model on. Since we are building an extremely simple model, this number can be relatively small. The dataset for this purpose is simple, we want the model to double inputs, so we need to give it numbers as inputs and then we tell it to compare its answer to double that input. In the second line, I use python list comprehension and PyTorch’s randn function to generate a list of pairs where the first component is the input and the second is the expected answer ($2 \times input$ in our case). The first line is a way of simplifying later stages, we create a TensorDataset using the data we have just created. This will allow us to pass the data easily to a trainer via a DataLoader.

train_size = 20     # Size of training set
train_X = [[i, 2*i] for i in torch.randn(train_size, dtype=torch.double)]
dataset = TensorDataset(torch.tensor(train_X))

PyTorchLightning Model

The class, Times2Model, outlined in the code snippet below defines our PyTorch model. PyTorchLightning allows us to create a PyTorch model by implementing the methods listed in shown in the snippet.

torch.set_default_dtype(torch.double)

class Times2Model(pl.LightningModule):
    def __init__(self):
        super().__init__()
        self.fc1 = nn.Linear(1,1)
        self.criterion = nn.MSELoss()

    def forward(self, x):
        return self.fc1(x)

    def training_step(self, batch, batch_idx):
        x, y = batch
        y_hat = self(x)
        loss = self.criterion(y_hat, y)
        return loss

    def configure_optimizers(self):
        return torch.optim.SGD(model.parameters(), lr=0.01, momentum=0.9)

Init Function

In the initialisation function we declare our model architecture using PyTorch to provide the Fully Connected or Linear layer along with the criterion function which we will use as our loss function. Since we are creating a lone perceptron, our fully connected layer consists of just one node. Our perceptron is learning to double a single given input, the layer needs just that; one input along with a single output (hence the (1,1) pair passed to the Linear layer).

Feed Forward Function

In forward(self, x), we need to define what happens when the model receives an input. Since we have such a simple model, we just pass the input, x, through our fully connected perceptron and return the output.

Note, this definition defines the behaviour of passing input to the model directly such as in model(x).

Training Step

In the training step, the goal is to make a prediction with our model, calculate the error between its prediction and the expected value and then return the error so that the model can adjust its weight accordingly.

Optimiser Configuration

In this function we define which optimiser for the model to use. This optimiser then controls weight adjustment according to the parameters provided.

Trainer

trainer = pl.Trainer(max_epochs=5)
model = Times2Model()
train_loader = DataLoader(train_X)
trainer.fit(model, train_loader)

Manual Evaluation

for i in torch.randn(5, dtype=torch.double):
    print(f"Expected: {2*i}")
    print(f"Actual: {model(torch.tensor([i]))[0]}")

The above snippet generates 5 random samples to test our trained model on. Then it prints the expected value (which we find by simply multiplying by 2) followed by the value outputted by the model.

for weight in model.parameters():
    print(weight)

Finally in this snippet, I print out the single weight (which should be extremely close to two if we have done things correctly!) and the bias (which should be 0).

Complete File

View the complete python script (hosted on github) below:

POS Tags Simplified

Sat, 17 Oct 2020 11:32:14 +0300

Introduction

Part-of-Speech tagging is a very useful foundation of NLP and deeper NLP concepts. The action involves analysing text and returning the tokens of the text with the appropriate Part-of-Speech (POS) tags.

POS Tags

POS Tag	Meaning	Example
ADJ	adjective	super cat
ADP	apposition	my friend Liam
ADV	adverb	The boy ran quickly
AUX	auxiliary	He will make
CCONJ	coordinating conjunction	this and that
DET	determiner	the squirrel
INTJ	interjection	Oi!
NOUN	noun	the dog
NUM	numeral	one fork
PART	particle	not Sam ’s
PRON	pronoun	he shouts
PROPN	proper noun	Helsinki is beautiful
PUNCT	punctuation	Hello , there !
SCONJ	subordinating conjunction	I do this while they do that
SYM	symbol	5 + 10
VERB	verb	They think that
X	other	this asd;lfkjasd;flkj

Source: Universal POS tags

Above is a list of the standardised POS tags. You will probably recognise many of them from English class.

Example

Courtesy of Spacy’s visualiser (as always!), below I have included an example where the phrase “This is my house while I live here” has been analysed and POS tags have been assigned. You can see that the tags line up with what would be expected from the list above.

How Are POS Tags Assigned?

There are many different ways that POS Tags are assigned. These methods include dynamic programming algorithms (such as the popular Viterbi algorithm). It is common to see hidden Markov models implemented in POS-tagging algorithms. As with many modern NLP elements, machine learning is now very popular for POS-tagging. In this case, computers analyse corpora of text which has been appropriately tagged already and try to learn how to tag tokens itself.

Named Entity Recognition (NER) Simplified

Sat, 12 Sep 2020 20:53:28 +0300

Introduction

This blog post is post number two in a series aimed at making Natural Language Processing topics more accessible by abstracting these topics away from mathematics and implementation details.

Defining Named Entity Recognition

Named Entity Recognition (NER) is the detection and labelling of named entities (organisations, people, locations etc.) within a text.

Here is an example of what an NER analysis returns on a given sentence (using spaCy’s NER and visualiser):

Tags (labels such as organisation) can vary between different systems and implementations but they will usually include:

ORGanisation
(GPE) Geo-Political Entities
PERSON

Other categories you may encounter include location, money and time.

What Makes NER Difficult?

At first glance, the task can seem very easy. However, after considering a few examples it can equally quickly become clear how the task could be troublesome for a machine.

“First Lady Makes an Appearance at John Smith’s”

Are we discussing the first lady to ever exist or are we talking about the president’s wife here? Is John Smith’s a pub, a person’s house or something completely different? And, more importantly, how can a computer know?

Approaches to NER

There are several different approaches that people use to meet their NER requirements. Generally, these can be broken down into techniques using statistics (including machine learning) and techniques based on grammar. Obviously most implementations take a combination of both of these approaches.

More grammar-based techniques involve a higher labour cost but see much more accurate results.
Statistical approaches produce slightly less accurate results but can analyse sample sets much quicker. A common bottleneck for statistical approaches is the amount of annotated data (these are sentences like in the picture above which are labelled correctly so that the computer can learn how to label too).

Experimenting with NER

Now that you hopefully have a baseline understanding of what NER is, I could not end this post without suggesting using the NLP package spaCy’s NER feature and visualiser (which I even used when making this post)!

You can find an interactive code playground here where you can change anything from the NLP pipeline or just the sentence to analyse.

Word Vectors Simplified

Fri, 04 Sep 2020 20:53:28 +0300

Note: This blog post is based on assignment 1 from the Stanford CS 224N NLP And Deep Learning Course which is available here. I highly recommend this course for people beginning NLP as it is freely available, has great content and is great fun to follow!

Introduction

Below I hope to outline the concept of word vectors and to show how useful they can be. With the aim of keeping this concise, I will not be discussing implementation details. However these can be found in the course linked at the beginning of this post.

Word vectors (or word embeddings) are vector representations of the meaning of a given word.

Finding Word Meaning From Surrounding Words

Word vectors commonly rely on the fact that words which are commonly found next or close to other words are usually linguistically related (either syntactically or semantically).

For example, it is natural to think that you would find the word “trombone” in contexts with a musical theme so you could predict other words which might be in the text such as “instrument” or “song”. You would probably also say that it is unlikely that you would find the word “kebab” around the word “trombone” because of their very different meanings.

In real NLP practices, many of the words surrounding a word are used to create a mathematical definition of the word. This number of words is commonly referred to as the window.

Here is an example of an active window when our centre word is “snowflakes” and with a window size of 1:

Co-Occurrence Matrices

An easy way to represent how frequently words are in the context of other words is to use a co-occurrence matrix. The simple way to think of a co-occurrence matrix is that it is a table where the values are counters of how many times two words co-occur!

“the snowflakes fall from above”
“some raindrops fall from above”

Given the sentences above with a window size 1, we would get the following co-occurrence matrix:

Synonyms from Vector Similarity

Once you have the vector representations of each word calculated, you effectively have vector definitions for each word. It turns out that you can use vector calculations to interact with these representations. For example, many people learn how to find angles between vectors using cosine similarity.

$$ similarity = cos(\theta) = \frac{\mathbf{A \cdot B}}{\Vert A \Vert \Vert B \Vert} $$

The more similar the two vectors, the more closely related the two words are likely to be in meaning.

Using Vector Maths to Find Semantic Relations

An interesting find which is discussed in the course practical this is based on, revolves around the difference in vectors and using vector representations to explore relations between words as well as meanings.

One of the examples uses the the roles of King and Queen and gensim’s most_similar() to investigate. They show that the difference between man and king should be the same vector difference between queen and woman. Hence:

$$ woman + king - man = queen $$

Flattening Matrices for Graphical Representation

Once we have a co-occurrence matrix we can see that the dimensions are too large to display on a standard 2D or 3D graph (and would but much much larger in a practical situation with a corpus consisting of more than 7 words)!

In order to represent our matrix on a graph we will have to shrink the matrix so that we have appropriate x and y coordinates.

A popular way to do this is to use SVD (singular value decomposition) .

Since this post is about keeping it simple I won’t go into how SVD works but here is a useful resource from MIT on understanding SVD if you want to delve deeper. The key thing for us is that SVD will help us through dimensionality reduction (going from an n x n matrix to a 2 x n matrix).

Tue, 28 May 2019 00:00:00 +0000

Adam Hawley

How Intel Server CPUs Save Power - Intro to C-states

What are C-states?

Differences between “hardware” and “software” C-states

How are C-states used to save power?

What are the different C-states?

Wake Latency

How can I modify C-states on Linux?

Further reading

Connecting to Firestore - Link-Sharing Site Part 3

Introduction

Handling Authentication

Web Component Redirects

Signing In

Firestore

Adding Links

Reading Links

Conclusion

Get Started with JavaScript Promises (in Under 2 Minutes)

Intro

Basics of JS Promises

Conclusion

Initialising a Firebase App - Link-Sharing Site Part 2

Introduction

Deciding on a Storage Solution

Firebase

Initialising a Firebase Project

Problems with FirebaseUI

Creating an Sign-Up Page

Conclusion

Creating a Link-Sharing Site Part 1

Introduction

Building the Basics

A Page for Consuming

A Page for Producing

Conclusion

Creating a Link-Sharing Site Part 0

Introduction

Motivation - Why am I doing this?

Showing My Work

Technology - How am I going to build this thing?

Keep in Touch

Using 'git rebase' to Perfect Commits

Mastering ‘git’ with ‘git rebase’

Introduction

What does ‘git rebase’ actually do?

GraDiAn - the Grammatical Distribution Analyser

Introduction

Data Types

SentTree

Syntactic Dependency Counter (SDC)

Example Usage

TicTacGo - An Intro to Golang

Introduction

Board

The API

About

About Me

Contact Me

Work Experience

Donate

Monero

Creating a Perceptron in PyTorch Lightning

Introduction

PyTorch Lightning

Code

Creating the Dataset

PyTorchLightning Model

Init Function

Feed Forward Function

Training Step

Optimiser Configuration

Trainer

Manual Evaluation

Complete File

POS Tags Simplified

Contents

Introduction

POS Tags

Example