第十三號艦隊
0%

Posted on Edited on In ,

看了知乎這篇
之後才知道inline博大精深

先看程式碼

1
2
3
4
5
inline void f(void) { }
int main()
{
        f();
}

用g++編譯這段程式，不管下-O2或是-O0都編譯的過
而如果用gcc編譯的話，-O0會出現unrefernce error，但如果下-std=gnu89又沒問題

根據知乎上面寫的，正確的修復方式應該為

1
extern void f(void) {}

C++跟C99之後，語意分歧點越來越多啊

Posted on Edited on In

Rollback changelist是很常做的事情，不過在git這種分散式控制系統就有點麻煩了
假設我們現在有這樣的Commit history

1
2
3
4
5
$ git log --oneline
e922d2b (HEAD -> master) ver 4
1b01602 ver 3
10dd293 ver 2
72d57f9 ver 1

而我們現在要退回ver 2該怎麼做

危險的作法

直接開大絕

1
2
$ git reset 10dd293 --hard
$ git push origin master

然而自己一個人玩玩還行，團體行動絕對沒有人建議這麼做

安全的作法

1
2
3
4
5
6
7
8
$ git checkout 10dd293 -b v2 # 切換新分支
$ git merge -s ours master
$ git log --oneline
ce6c1ea (HEAD -> v2) Merge branch 'master' into v2
e922d2b (master) ver 4
1b01602 ver 3
10dd293 ver 2
72d57f9 ver 1

可以看見HEAD指向v2的new commit了，比較一下

1
$ git diff HEAD..10dd293

然後可以把v2推向remote了

1
2
3
$ git push origin master
$ git push origin v2:master
$ git push origin HEAD:master

三者等價

Reference

— 安全地回滚远程分支

Posted on Edited on In

再不寫點東西，這邊就長草了
這幾天在看go-redis專案，顧名思義就是在golang當中對redis操作的程式庫

其中有一段程式碼是這樣

1
2
3
4
5
6
func ExampleClient() {
	err := client.Set("key", "value", 0).Err()
	if err != nil {
		panic(err)
	}
}

結果去redis.go裡面查看，找不到Set這個函數的實作
只好用grep去找哪邊可能實作這個函數
最後讓我在command.go找到

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
func (c *cmdable) Set(key string, value interface{}, expiration time.Duration) *StatusCmd {
	args := make([]interface{}, 3, 4)
	args[0] = "set"
	args[1] = key
	args[2] = value
	if expiration > 0 {
		if usePrecise(expiration) {
			args = append(args, "px", formatMs(expiration))
		} else {
			args = append(args, "ex", formatSec(expiration))
		}
	}
	cmd := NewStatusCmd(args...)
	c.process(cmd)
	return cmd
}

在同一個檔案中找到cmdable的定義

1
2
3
type cmdable struct {
	process func(cmd Cmder) error
}

回頭看我們的redis.go，發現一樣的東西

1
2
3
4
type baseClient struct {
    // Ignore unrelated fields
	process           func(Cmder) error
}

因為有同樣的Singature，所以可以把baseClient當cmder`來用

所以？

雖然找到了我想要的答案，不過我不喜歡這方法
由於我找不到Set這函數，於是我需要grep找到可能的實作 => 發現baseClient和cmadble的相似處
那為什麼不直接用繼承關係就好了，這樣可以找到相依性

1
2
3
4
5
6
struct ICmdable {
    virtual std::error process(...) = 0;
};
struct baseClient : ICmdable {
    std::error process(...) override;
};

這樣可以看出baseClient必須繼承’ICmdable’這個介面
不過可能引申出多重繼承的問題，老話一句，沒有什麼方法一體適用

Posted on Edited on In ,

現在在科技業沒講個深度學習會被翻白眼，Prototype是一回事，放進Product又是另一回事
之前一般來說通用信的選擇是Tensorflow，雖說Prototype跟Product可以一起完成
不過C++那端難寫就算了，Python那邊也麻煩的要死，沒太多精力搞這個
後來看到PyTorch，Onnx，以及Caffe2改變了想法
用易學易用的PyTorch建構出Onnx Mdoel，透過Onnx轉換成Caffe2 Model，加上對終端最佳化的Caffe2 Library
變成另外一種可行的解法
我自己的實驗結果就放在 GitHub
其中C++ Demo的部分是從Caffe2 Android Example那邊學來的
雖然看起來不多，不過真正讓他可以動倒是花了不少時間

Posted on Edited on In ,

過年前有個工作需求，需要跨平台的AES硬體加速功能，研究了一下幾種方案
– Openssl (增加相依性，加上編譯時需要設定改來改去)
– Runtime JIT (先判斷CPU種類，然後根據CPU類型生成組合語言，小小的玩意哪需要玩這麼大)
– libkcapi – Linux Kernel Crypto API User Space Interface Library
覺得最後一種方式不錯，不過我只需要AES，其他地方可以拿掉
因此對這Project進行二次加工，產生了KCAES這個專案
不過在進行AES CBC運算時，發現長度超過64K就會報錯，只好對超過64K的Block進行二次加工
不需要其他的相依性，只要把檔案放進自己的專案，加入編譯即可

Posted on Edited on In

去英國晃了一圈，回來還是寫點東西，免得生疏了

static_assert

沒什麼好說的，就是static_assert改成允許單參數，直接看程式碼

Before C++17

1
static_assert(sizeof(short) == 2, "sizeof(short) == 2")

After C++17

1
static_assert(sizeof(short) == 2)

Inline Variables

對Header-Only library特別有用，不過我不喜歡Header-Only library
原先如果要定義一個變數，要在header宣告，在source code裡面定義
現在可以直接寫在header裡了

Before C++17:

1
2
3
4
5
// foo.h
extern int foo;

// foo.cpp
int foo = 10;

After C++17:

1
2
// foo.h
inline int foo = 10;

constexpr labmda

原先C++14辦不到，C++17允許的能力

1
2
3
4
5
constexpr int Func(int x)
{
  auto f = [x]() { return x * x; };
  return x + f();
}

不過我還沒想到這東西可以做啥

capture [*this]

原本我還搞不懂capture [this]和capture [*this]有什麼不同，自己寫了一個範例之後搞懂了

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#include <string>
#include <iostream>
struct Obj {
    Obj() = default;
    Obj(const Obj&) { std::cout << "Copy Constructor\n"; }
    void f() {}
    void g() {}
    void h() {}
    void func() {
        auto lambda1 = [this]() mutable { f(); };
        auto lambda2 = [self = *this]() mutable { self.g(); };
        auto lambda3 = [*this]() mutable { h(); };
        lambda1();
        lambda2();
        lambda3();
    }
};
int main()
{
    Obj o;
    o.func();
}

capture [*this]相當於上面的[self = *this]，會將原有的物件複製一份
而[this]不會

More Attributes

C++11引進了Attribute，在C++17增加了更多attributes，如[[fallthrough]]等
就是把GCC/VC的attribute標準化，不多做解釋了

Rest

至於STL的加強就不特別寫了, Guaranteed Copy Elision可能要另外寫
就先寫到這了

Reference

— cpp17_in_TTs
— C++17

Posted on Edited on In

if constexpr

以往我們可能寫出類似這樣的程式碼

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#include <string>
template <typename T>
int func(T) {
    return -1;
}
template <>
int func(std::string v)
{
    return 12;
}
template <>
int func(int)
{
    return 34;
}
int main()
{
    return func(std::string("123"));
}

如今我們可以寫成這樣

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#include <string>
template <typename T>
int func(T) {
    if constexpr (std::is_same_v<T, std::string>) {
        return 12;
    } else if constexpr(std::is_same_v<T, int>) {
        return 34;
    } else {
        return -1;
    }
}
int main()
{
    return func(std::string("123"));
}

省去了很多的冗於
如果配合variant來使用，程式碼可以寫成這樣

1
2
3
4
5
6
7
8
9
10
11
12
#include <string>
#include <variant>
using unionType = std::variant<std::string, int>;
int main()
{
    unionType v = 3;
    return std::visit([](const auto &v) {
        using T = std::decay_t<decltype(v)>;
        if constexpr (std::is_same_v<T, int>) return 12;
        else return 34;
    }, v);
}

Class Deduction guide

在c++17之前，寫了很多這樣子的程式碼

1
2
std::mutex m;
std::lock_guard<std::mutex> lock(m);

為什麼函數可以推導出型別，而類型不行，於是C++17放寬了這條件

1
2
std::lock_guard lock(m);
std::vector v{1, 2, 3};

當然，也是有explicit class deduction guide的，請參考reference

template <auto>

目前看起來沒什麼用的feature
未用c++17前程式碼長這樣

1
2
3
4
5
template <typename T, T v>
struct integral_constant {
    static constexpr T value = v;
};
integral_constant<int, 1024>::value;

用了C++17後

1
2
3
4
5
template <auto v>
struct integral_constant {
    static constexpr auto value = v;
};
integral_constant<1024>::value;

nested namespace

早該有的東西, 結果拖到這麼後面才加進來

1
2
3
4
5
namespace X {
    namespace Y {
        struct Foo;
    }
}

現在可以寫成

1
2
3
namespace X::Y {
    struct Foo;
}

Fold expression

以加法為範例
在c++17之前的寫法

1
2
3
4
5
6
7
8
template<typename T>
T sum(T v) {
    return v;
}
template<typename T, typename... Args>
T sum(T first, Args... args) {
    return first + sum(args...);
}

把sum寫成兩部分，雖然不是不行，不過總覺得被切割加重學習負擔
用上if constexpr

1
2
3
4
5
6
7
8
template<typename T, typename... Args>
T sum(T first, Args... args) {
    if constexpr (sizeof...(Args) == 0) {
        return first;
    } else {
        return first + sum(args...);
    }
}

好一點了，用上Fold expression會變成怎樣

1
2
3
4
template<typename ...Args>
auto sum(Args&&... args) {
    return (args + ...); // OK
}

跟if constexpr方法比是更精簡了一點，不過多了一堆語法規則，實在不太划算

Reference

— A Tour of C++ 17: If Constexpr
— C++17中的deduction guide
— C++17 Fold Expressions

Posted on Edited on In

對於C++17特性的文章已經有很多了，歸納自己的想法寫成幾篇文章

if / switch init

覺得很有用的特性之一
在沒有C++17之前，程式碼大概長這樣

1
2
3
4
5
6
7
8
void test() {
        Foo *ptr = get_foo();
        if (!ptr)
                do_something();
        else
                ptr->do_something();
        more_code();
}

在C++17之後

1
2
3
4
5
6
7
void test() {
        if (Foo *ptr = get_foo(); !ptr)
                do_something();
        else
                ptr->do_something();
        more_code();
}

Structure Binding

在沒有Structure Binding時，程式碼大概長這樣

1
2
3
4
std::tuple<int, double> stuff();
auto tup = stuff();
int i = std::get<0>(tup);
double d = std::get<1>(tup);

或者是

1
2
3
int i;
double d;
std::tie(i, d) = tup;

不過都比不上

1
auto [i, d] = stuff();

傳統的

1
errcode doSomething(obj *out_value);

之後會變成

1
2
std::tuple<obj, errcode> doSomething();
auto [obj, err] = doSomething();

有點golang的感覺

不過看看以下程式碼

1
2
3
4
5
6
7
8
9
10
11
struct Foo
{
        int x = 0;
        std::string str = "world";
        ~Foo() { std::cout << str << "\n"; }
};
{
	auto [x, s] = Foo();
	std::cout << "Hello ";
	s = "Goodbye";
}

結果出乎意料，不是大家所想的copy by value，而是copy by reference
Compiler大概做的是像這樣

1
2
3
4
5
6
int main()
{
        auto temp = Foo();
        std::cout << "Hello ";
        temp.str = "Goodbye";
}

還有下面這個範例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
struct X { int i = 0; };
X makeX();
int main()
{

        X x;

        auto [ b ] = makeX();
        b++;
        auto const [ c ] = makeX();
        c++;
        auto & [ d ] = makeX();
        d++;
        auto & [ e ] = x;
        e++;
        auto const & [ f ] = makeX();
        f++;
}

– c++ 編譯不過，因為這是bind to const reference
– auto & [d] = makeX() 編譯不過，因為left reference不能bind to right value
– f++ 編譯不過，理由同第一條

Reference

— cpp17_in_TTs

Posted on Edited on In

看看以下程式有什麼不一樣

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#include <iostream>
using namespace std;
struct Obj {
	Obj() { cout << "Default Constructor\n"; }
	~Obj() { cout << "Destructor\n"; }
	Obj(const Obj &) { cout << "Copy Constructor\n"; }
	Obj(Obj &&) { cout << "Move Constructor\n"; }
};
template <typename T>
auto outer(T && obj) {
	return std::forward<T>(obj);
}

int main()
{
	auto& obj = outer(Obj());
	return 0;
}

和

1
2
3
4
template <typename T>
decltype(auto) outer(T && obj) {
	return std::forward<T>(obj);
}

差異就在於auto和decltype的用途不太一樣，auto會去掉reference，而decltype(auto)不會

C++11’s solution

C++11也可以達到decltype(auto)的方式，不過寫法比較繁瑣

1
2
3
4
template <typename T>
auto outer(T&& obj) -> decltype(std::forward<T>(obj)) {
	return std::forward<T>(obj);
}

Posted on Edited on In

cgroup是linux用來限制program使用Computer resource的一種方法
也是Docker的基礎

首先先安裝cgroup

1
2
3
4
5
6
7
8
$ sudo apt install cgroup-bin
``` 
寫個程式

``` python
count = 0
while True:
        count = count + 1

不用看也知道他絕對吃滿cpu resource

所以該怎麼限制，例如只讓他吃20%的CPU

先建立cgroup的群組

1
2
3
4
5
$ cd /sys/fs/cgroup/cpu # 管理CPU資源的地方
$ sudo mkdir calm # 建立一個目錄
$ ls calm # 自動產生和cpu有關的規則
cgroup.clone_children  cpuacct.stat   cpuacct.usage_percpu  cpu.cfs_quota_us  cpu.stat           tasks
cgroup.procs           cpuacct.usage  cpu.cfs_period_us     cpu.shares        notify_on_release

接著把我們程式限制的規則加入群組 以下動作需要root權限，sudo無法執行

1
2
$ echo 20000 > calm/cpu.cfs_quota_us # 預設值是100000，20000正好是20%
$ echo 3255 > calm/tasks # 3255 是程式的 PID

接著我們就能看到程式CPU使用率就只剩20%了

Another method

也可以用自定義規則的方式

1
2
3
4
$ sudo cgcreate -g cpu:calm # 一樣是建立 cpu calm
$ sudo cgset -r cpu.cfs_quota_us=20000 calm # 跟上面差不多
$ sudo cgget calm # 列出calm的所有規則
$ sudo cgdelete calm

如果要執行程式的話

1
$ sudo cgexec -g cpu:calm python busy.py

跟上面有同樣的效果