DEV Community: Vir

A Compiler optimization area

Vir — Tue, 30 Aug 2022 16:17:35 +0000

While applying for a role in Compilers, the interviewer asked me about my LICM (Loop Invariant Code Motion) optimization pass. This is where variables inside the loop which compute the same value, can be moved outside of the loop, reducing the number of instructions for a loop to compute.

I answered them, the LICM pass would move invariant instructions (with no side effects, i.e. loads, stores, calls, volatile, etc) which had invariant operands. Instructions which always compute the same thing would be moved out. Also, they need to be part of the dominator tree. e.g. Guards (if - checks)

They asked me, what about mutable Global Variable. Short answer: No, can't be optimized.

Complex answer: Might be able to.

A global variable mutated a couple of times (on any threads), stabilizes in value, then goes through the loop. In this situation, it can be utilized as a constant
In context of GPUs, Global Variable are utilized a lot for multiply and add instructions. These require simultaneous concurrent multiple Read Write requests to the global variable. Here, this variable would not be touched by the LICM pass.

I believe optimizing this mutable global variable can be done better at the Intermediate pass before generating LLVM or using MLIR a pass.

Is it worth it? I think the complexity is far too much on detecting these global variables if they are mutated. The time can be better spent on working on other areas of the compiler.

The optimization problem can be solved by the software developer in a rather easier way:

PreOptimization:

  int x = 5; // Defined Global scope across multiple threads
  x++;
  thread1 {
    x++;
  }
  waitForThread1ToComplete();
  while (true) {
    print(x*x); // x is global mutable, and is mutated, can't LICM
// is mutated: meaning if not mutated, can show error to dev

Developer written suggestions: Use an intermediate constant variable and assign the global variable to it

  waitForThread1ToComplete();
  const int copyX = x;
  while (true) {
    print(copyX*copyX); // copyX is constant, LICM can optimize this

First week of uncomfortable

Vir — Tue, 18 Jan 2022 04:03:07 +0000

I recently started Masters education at NC State University.

In the first week here I enrolled in Architecture of Parallel Computers. In the 2nd lecture I felt lost, couldn't understand anything and failed to answer 3 of 4 questions asked via Google Forms to the whole class. I aced the 3rd question and it was marked good by the Professor, but, I failed the other 3.

After the class, I felt stressed out and questioned my life decisions, did I make a mistake of returning to Academia? will I have to abandon my studies and return home? will I be a capable person? will I fail studies just because I am using decade old Macbook Pro 2012 with a Hard Disk Drive in 2022?

These feelings reverberated for 2 days, and I communicated with my friends what I felt.

Then, I involved myself in the first assignment for the same course. I started setting up the environment, trying to heck and peck into what is there, read the assignment, questions, etc. 8 hours down and I was able to solve it on my own.

It resulted in a drastic change of my emotional state.
I began to feel energetic, forward-looking, enthusiastic.
24 hours ago I was feeling depressed, failed, handicapped.

Putting in efforts has been sexy, and I feel in control of my life. :D

Making a Cell View in SwiftUI

Vir — Mon, 20 Apr 2020 12:02:54 +0000

Let's make a View in SwiftUI which looks like a TableView / CollectionView Cell. All the code has been tested in Xcode Playgrounds, feel free to use it https://gist.github.com/Viranchee/87bfe6b39ae86bcc9b5b6f5d4b34d691

We will develop with Swift Playgrounds with Live View so as to easily test and debug. Open Xcode -> New Playgrounds -> Blank Playgrounds -> (Indicate where to save the file). Now run your file using Cmd+Shift+Enter and you can see the output on right side of the screen. Since we will be rendering UI, we will make use of PlaygroundSupport. So go ahead, write these lines

import SwiftUI
import PlaygroundSupport

To run any SwiftUI View inside Playground, we will use the setLiveView method.

PlaygroundPage.current.setLiveView(Cell1())

Let us try to make a Cell with Image, Title and Subtitle
To view the live view, press Cmd+Option+Enter

struct Cell1: View {
  var body: some View {
    HStack {
      Image(systemName: "music.house")
      VStack {
        Text("Title")
        Text("Subtitle")
      }
    }
  }
}
PlaygroundPage.current.setLiveView(Cell1())

Now let us give a shadow to the view. We use the background, stroke, shadow and foregroundColor modifiers on the View.

Note: ... means extra code which is same as the implementation in above snippet.

HStack {
      ...
    }
    .background(
      RoundedRectangle(cornerRadius: 5)
        .stroke(Color.yellow)
        .shadow(color: .gray, radius: 2.5, x: 0.6, y: 0)
        .foregroundColor(.white)
    )

Interesting!

Now let us widen the view by increasing the text. Also let's fix our Image

Let's use the resizable, aspectRatio, frame and padding modifiers on the Image and increase the length of our subtitle string

HStack(spacing: 0) {
      Image(systemName: "music.house")
        .resizable()
        .aspectRatio(1, contentMode: .fit)
        .frame(height: 50)
        .padding()

      ...
    }
    .background(...)

Great!

Let's fix the Title Text and make it have a green background

I will use the bold italic lineLimit maximumScaleFactor padding background foregroundColor modifiers here

VStack(alignment: .leading) {
        Text("Title")
          .bold()
          .italic()
          .lineLimit(1)
          .minimumScaleFactor(0.8)
          .padding(.horizontal, 10)
          .padding(.vertical, 2)
          .background(
            Capsule()
              .foregroundColor(.green)
        )
          .padding(.bottom, 5)
        ...

So far so good. Now let's modify the Subtitle Text

I will use these View Modifiers: lineLimit multilineTextAlignment truncationMode and a fixedSize modifier here.

Text("A long subtitle which extends more than a line")
          .lineLimit(2)
          .multilineTextAlignment(.leading)
          .truncationMode(.tail)
          .fixedSize(horizontal: false, vertical: true)

This completes much of our Cell View. Now, let us check how the View behaves under different circumstances, viz. different lengths of Title and Subtitle. To simulate the different sizes live, we will use the Slider which looks like such

struct SliderView: View {
  @State private var titleLength: CGFloat = 1  

  var body: some View {
        Text(String.init(repeating: "T", count: Int(self.titleLength)))
        Text("Title length")
        Slider(value: $titleLength, in: 1...100) {
// This Text is for Accessibility
          Text("Title")
}

Integrating the slider to control the Text length looks like such in code and output:

struct Cell6: View {
  @State private var titleLength: CGFloat = 1
  @State private var subtitleLength: CGFloat = 1


  var body: some View {
    VStack {


      HStack(spacing: 0) {
        Image(systemName: "music.house")
          .resizable()
          .aspectRatio(1, contentMode: .fit)
          .frame(height: 50)
          .padding()

        VStack(alignment: .leading) {
          Text(String.init(repeating: "T", count: Int(self.titleLength)))
            .bold()
            .italic()
            .lineLimit(1)
            .minimumScaleFactor(0.8)
            .padding(.horizontal, 10)
            .padding(.vertical, 2)
            .background(
              Capsule()
                .foregroundColor(.green)
          )
            .padding(.bottom, 5)
          Text(String.init(repeating: "S", count: Int(self.subtitleLength)))
            .lineLimit(2)
            .multilineTextAlignment(.leading)
            .truncationMode(.tail)
            .fixedSize(horizontal: false, vertical: true)
            .minimumScaleFactor(0.7)
        }
      }
      .background(
        RoundedRectangle(cornerRadius: 5)
          .stroke(Color.yellow)
          .shadow(color: .gray, radius: 2.5, x: 0.6, y: 0)
          .foregroundColor(.white)
      )

      HStack {
        Text("Title length")
        Slider(value: $titleLength, in: 1...40) {
          Text("Title")
        }
      }

      HStack {
        Text("Subtitle length")
        Slider(value: $subtitleLength, in: 1...100) {
          Text("Subtitle")
        }
      }
    }
  }
}

PlaygroundPage.current.setLiveView(Cell6())

Finally, we have crafted a SwiftUI View of our requirements and tested it with variety of input string size.

Credits: