kylez.org

I Got Google Open Source Peer Bonus Award 2023!

Sat, 22 Apr 2023 02:00:12 +0000

About a month ago, I received an email from Google OSPB, which told me that I was nominated for the Google Open Source Peer Bonus award.

At that time, I couldn’t believe it was true. After confirming repeatedly, I filled out the form. Recently, I received my award letter.

And I can’t wait to share it on my website:

In the past two years, I have contributed many patches to JGit, including performance optimization, refactoring, and various small features.

The most challenging work among them is the Commit-Graph feature, which cgit has actually implemented for a long time, and I have implemented it in JGit (refer to Gerrit Code Review)

In the end, I would like to thank Ivan (our great committer) for believing that my work on JGit deserves to be recognized. We made a big deal!

Thanks to jekyll-theme Biu

Fri, 21 Oct 2022 19:48:12 +0000

It is a modified version of butane-jekyll-theme by KayMW.

Principle of Volatile Keyword in Java

Thu, 27 Dec 2018 11:03:00 +0000

Low-level Principle

// instance is volatile variable
instance = new Singleton();

convert to assembly language:

0x01a3de1d: movb $0×0,0×1104800(%esi);
0x01a3de24: lock add1 $0×0,(%esp)

If a variable is declared to be volatile, process would execute lock command after movb when the varieble is written.

lock would do these two things in multi-core cpu:

Write the cache line of the current processor back to system memory
This operation of writing back to memory will invalidate the data cached at other cores of cpu.

Memory Semantics

When reading a valatile variable, JMM will invalidate the local memory corresponding to the thread. The thread will next read the shared variable from the memory.

Feature

Visibility: A read of a volatile variable always sees (any thread) the last write to the volatile variable.
Atomicity: The read/write of any single volatile variable is atomic, but compound operations like volatile++ are not atomic.

Atomicity in Compound Operations

Such as n ++ and n = n + 1.

Example:

public class Test {
    public volatile int inc = 0;
     
    public void increase() {
        inc++; //compound operations
    }     
    public static void main(String[] args) {
        final Test test = new Test();
        for(int i=0;i<10;i++){
            new Thread(){
                public void run() {
                    for(int j=0;j<1000;j++)
                        test.increase();
                };
            }.start();
        }    
        while(Thread.activeCount()>1)
            Thread.yield();
        System.out.println(test.inc);
    }
}

If variable inc is atomic, the result would be 10000. But in fact it is less than 10000.

There is a situation:

The inc value in memory is 10. In the inc ++ operation of thread 1, the original value of inc is read first. At this time, thread 1 is blocked, and then thread 2 performs inc ++ operation on the variable, and at this time thread 1 has not yet been written, so inc is still reading the main memory at this time, so it is still 10 (it should be 11).

Sorting Algorithms in Haskell

Sun, 21 Oct 2018 20:48:12 +0000

Insert Sort

select :: Int -> [Int] -> [Int]
select x [] = [x]
select x (y:ys)
        | x < y = x:y:ys
        | otherwise = y : delete x ys

insertSort :: [Int] -> [Int]
insertSort [] = []
insertSort (x:xs) = delete x (insertSort xs)

Merge Sort

merge :: [Int] -> [Int] -> [Int]
merge xs [] = xs
merge [] ys = ys
merge (x:xs) (y:ys)
        | x > y = y:merge (x:xs) ys
        | otherwise = x:merge xs (y:ys)

mergeSort :: [Int] -> [Int]
mergeSort [] = []
mergeSort [x] = [x]
mergeSort list = merge (mergeSort a) (mergeSort b)
       where 
           (a,b) = splitAt (div (length list)2) list

Quick Sort

quickSort :: [Int] -> [Int]
quickSort [] = []
quickSort (x:xs) = quickSort [a|a<-xs,a<=x] ++ [x] ++ quickSort [a|a<-xs,a>x]

Bubble Sort

swaps :: [Int] -> [Int]
swaps [] = []
swaps [x] = [x]
swaps (x1:x2:xs)
       | x1 > x2 = x2 : swaps(x1:xs)
       | otherwise = x1 : swaps(x2:xs)

bubbleSort :: [Int] -> [Int]
bubbleSort xs
           | swaps xs == xs =xs
           | otherwise = bubbleSort $ swaps xs

Select Sort

delete :: Int -> [Int] -> [Int]
delete _ [] = []
delete x (y:ys)
           | x == y =ys
           | otherwise = y:delete x ys


selectSort :: [Int] -> [Int]
selectSort [] = []
selectSort xs = mini : selectSort xs'
        where
            mini = minimum xs
            xs' = delete mini xs