LLVM入门系列之局部变量和全局变量

一、局部变量

1
2
int a = 1024;
return a;
1
2
3
4
5
6
//申请栈空间，并返回对应的指针
AllocaInst *variable = builder.CreateAlloca(builder.getInt32Ty());
//将值存储到指定的位置
builder.CreateStore(builder.getInt32(1024), variable);
//加在指定位置处的值
builder.CreateRet(builder.CreateLoad(variable));
1
2
3
4
5
6
7
define i32 @main() {
entry:
  %0 = alloca i32
  store i32 1024, i32* %0
  %1 = load i32, i32* %0
  ret i32 %1
}
more >>

更多内容 >>

LLVM入门系列之Hello-World

一、代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
#include <llvm/IR/Module.h>
#include <llvm/IR/IRBuilder.h>
#include <llvm/IR/LLVMContext.h>
#include <llvm/Support/TargetSelect.h>
#include <llvm/Bitcode/BitcodeWriter.h>
#include <llvm/Support/raw_os_ostream.h>
#include <llvm/ExecutionEngine/ExecutionEngine.h>
#include <llvm/ExecutionEngine/GenericValue.h>

#include <string>
#include <vector>
#include <iostream>
#include <fstream>

using namespace std;
using namespace llvm;

int main() {
    LLVMContext context;
    IRBuilder<> builder(context);
    Module module("test", context);

    /*1.声明puts函数*/
    FunctionType *puts_type = FunctionType::get(builder.getInt32Ty(), {builder.getInt8PtrTy()}, true);
    Constant *puts_func = module.getOrInsertFunction("puts", puts_type);  // puts? printf?

    /*2.定义main函数*/
    FunctionType *main_type = FunctionType::get(builder.getInt32Ty(), false);
    Function *main_func = Function::Create(main_type, Function::ExternalLinkage, "main", &module);

    BasicBlock *main_body = BasicBlock::Create(context, "entry", main_func);
    builder.SetInsertPoint(main_body);

    CallInst *ret_value = builder.CreateCall(puts_func, builder.CreateGlobalStringPtr("Hello,world!!!"));
    builder.CreateRet(ret_value);

    /*3.output*/
    fstream fs("test.bc");  // lli test.bc
    raw_os_ostream out(fs);
    WriteBitcodeToFile(module, out);
    outs() << module;

    /*4.JIT*/
    InitializeNativeTarget();
    InitializeNativeTargetAsmPrinter();

    unique_ptr<Module> owner(&module);
    ExecutionEngine *engine = EngineBuilder(move(owner)).create();

    GenericValue gv = engine->runFunction(main_func, {});
    outs() << "Result: " << gv.IntVal;  // 获取函数调用结果

    return 0;
}
more >>

更多内容 >>

LLVMLite入门之Hello-World

LLVMLite是一个Python版的接口，使用起来相对比较简单，可使用pip install llvmlite命令安装，使用代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
from llvmlite import ir
import llvmlite.binding as llvm

import os


def create_global_string(builder: ir.IRBuilder, s: str, name: str) -> ir.Instruction:
    type_i8_x_len = ir.types.ArrayType(ir.types.IntType(8), len(s))
    value = ir.Constant(type_i8_x_len, bytearray(s.encode('utf-8')))

    variable = ir.GlobalVariable(builder.module, type_i8_x_len, name)
    variable.linkage = 'private'
    variable.unnamed_addr = True
    variable.global_constant = True
    variable.initializer = value
    variable.align = 1

    zero = ir.Constant(ir.types.IntType(32), 0)
    return variable.gep((zero, zero))


module = ir.Module(name="demo")

puts_type = ir.FunctionType(ir.IntType(32), (ir.IntType(8).as_pointer(),), var_arg=True)
puts_func = ir.Function(module, puts_type, "printf")

main_type = ir.FunctionType(ir.IntType(32), ())
main_func = ir.Function(module, main_type, "main")

block = main_func.append_basic_block(name="entry")
builder = ir.IRBuilder(block)
msg = create_global_string(builder, 'Hello,world!\n', "msg")

result = builder.call(puts_func, (msg,))
builder.ret(result)

print(module)

# generate bc
module_ref = llvm.parse_assembly(str(module))
module_ref.verify()
open("test03.bc", "wb").write(module_ref.as_bitcode())

# generate obj
llvm.initialize()
llvm.initialize_native_target()
llvm.initialize_native_asmprinter()

target = llvm.Target.from_default_triple()
target_machine = target.create_target_machine(codemodel="small")

module.triple = llvm.get_default_triple()
module.data_layout = target_machine.target_data

obj = target_machine.emit_object(module_ref)
open('demo.o', 'wb').write(obj)

print("="*25, "execute", "="*25)
os.system("clang demo.o -o demo")
os.system("./demo")
more >>

更多内容 >>

CUDA入门系列之矩阵表示

一、代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
#ifndef CUDA_MAT_MAT_HPP
#define CUDA_MAT_MAT_HPP

#include <iostream>
#include <exception>
#include <sstream>

#include <cuda.h>
#include <cuda_runtime.h>

using namespace std;

#define CHECK(exp) \
if (exp != cudaSuccess) { \
    auto err = cudaGetLastError(); \
    printf("[ERROR] [%s:%d] %s(%d).\n", __FILE__, __LINE__, cudaGetErrorString(err), err); \
    exit(-1); \
}

template<class T>
class Mat {
  template<class K>
  friend ostream &operator<<(ostream &stream, const Mat<K> &mat);

public:
  Mat() : row_(0), col_(0), size_(0), cpu_data_(nullptr), gpu_data_(nullptr) {};

  Mat(size_t r, size_t c, bool use_cuda = false) : row_(r), col_(c), size_(r * c * sizeof(T)) {
    if (!use_cuda) {
      CHECK(cudaMallocHost(&cpu_data_, size_));
      gpu_data_ = nullptr;
    } else {
      cpu_data_ = nullptr;
      CHECK(cudaMalloc(&gpu_data_, size_));
    }
  }

  Mat(const initializer_list<T> &init_data) : Mat(1, init_data.size()) {
    T *q = cpu_data_;
    for (auto p = init_data.begin(); p != init_data.end(); p++, q++) {
      *q = *p;
    }
  }

  Mat(const initializer_list<initializer_list<T>> &init_data) : Mat(init_data.size(), init_data.begin()->size()) {
    T *q = cpu_data_;
    for (auto p1 = init_data.begin(); p1 != init_data.end(); p1++) {
      if (p1->size() != col_) {
        stringstream ss;
        ss << "The expected col is " << col_ << ", but the actual value is " << p1->size();
        throw invalid_argument(ss.str().c_str());
      }

      for (auto p2 = p1->begin(); p2 != p1->end(); p2++, q++) {
        *q = *p2;
      }
    }
  }

  Mat(const Mat &rhs) noexcept: row_(rhs.row_), col_(rhs.col_), size_(rhs.size_) {
    if (rhs.cpu_data_) {
      CHECK(cudaMallocHost(&cpu_data_, size_));
      CHECK(cudaMemcpy(cpu_data_, rhs.cpu_data_, size_, cudaMemcpyHostToHost));
    } else cpu_data_ = nullptr;

    if (rhs.gpu_data_) {
      CHECK(cudaMalloc(&gpu_data_, size_));
      CHECK(cudaMemcpy(gpu_data_, rhs.gpu_data_, size_, cudaMemcpyDeviceToDevice));
    } else gpu_data_ = nullptr;
  }

  Mat(Mat &&rhs) noexcept: row_(rhs.row_), col_(rhs.col_), size_(rhs.size_), cpu_data_(rhs.cpu_data_),
                           gpu_data_(rhs.gpu_data_) {
    rhs.col_ = rhs.row_ = rhs.row_ = 0;
    rhs.gpu_data_ = nullptr;
    rhs.cpu_data_ = nullptr;
  }

  Mat &operator=(const Mat &rhs) {
    Mat tmp(rhs);
    swap(tmp);
    return *this;
  }

  ~Mat() {
    if (cpu_data_)cudaFreeHost(cpu_data_);
    if (gpu_data_)cudaFree(gpu_data_);
  }

  Mat &cuda() {
    if (cpu_data_) {
      if (!gpu_data_)CHECK(cudaMalloc(&gpu_data_, size_));
      CHECK(cudaMemcpy(gpu_data_, cpu_data_, size_, cudaMemcpyHostToHost));
    }
    return *this;
  }

  Mat &cpu() {
    if (gpu_data_) {
      if (!cpu_data_)CHECK(cudaMallocHost(&cpu_data_, size_));
      CHECK(cudaMemcpy(cpu_data_, gpu_data_, size_, cudaMemcpyDeviceToHost));
    }
    return *this;
  }

  void swap(Mat<T> &rhs) {
    std::swap(row_, rhs.row_);
    std::swap(col_, rhs.col_);
    std::swap(size_, rhs.size_);
    std::swap(cpu_data_, rhs.cpu_data_);
    std::swap(gpu_data_, rhs.gpu_data_);
  }

  inline const T *cpu_data() const { return cpu_data_; }

  inline T *cpu_data_mutable() { return cpu_data_; }

  inline const T *gpu_data() const { return gpu_data_; };

  inline T *gpu_data_mutable() { return gpu_data_; }

  inline size_t row() const { return row_; }

  inline size_t col() const { return col_; }

private:
  T *cpu_data_, *gpu_data_;
  size_t row_, col_, size_;
};

template<class T>
ostream &operator<<(ostream &stream, const Mat<T> &mat) {
  if (mat.cpu_data_ == nullptr) {
    return stream;
  }

  T *p = mat.cpu_data_;
  for (size_t r = 0; r < mat.row_; r++) {
    for (size_t c = 0; c < mat.col_; c++) {
      stream << *p++ << " ";
    }
    stream << "\n";
  }

  return stream;
}
#endif //CUDA_MAT_MAT_HPP
more >>

更多内容 >>

CUDA入门系列之加法运算

一、代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
// main.cu
#include <iostream>

#define CHECK(exp) \
if (exp != cudaSuccess) { \
printf("[ERROR] [%s:%d] %d\n", __FILE__, __LINE__, cudaGetLastError()); \
exit(-1); \
}

template<typename T>
__global__ void add(const T *a, const T *b, T *c, size_t n) {
  auto i = blockDim.x * blockIdx.x + threadIdx.x;
  if (i >= n)return;
  c[i] = a[i] + b[i];
}

int main() {
  float *a, *b, *c;
  size_t n = 1000;

  CHECK(cudaMallocHost(&a, n * sizeof(float)));
  CHECK(cudaMallocHost(&b, n * sizeof(float)));
  CHECK(cudaMallocHost(&c, n * sizeof(float)));

  for (int i = 0; i < n; i++) {
    a[i] = static_cast<float>(i);
    b[i] = static_cast<float>(i * i);
  }

  float *a_gpu, *b_gpu, *c_gpu;
  CHECK(cudaMalloc(&a_gpu, n * sizeof(float)));
  CHECK(cudaMalloc(&b_gpu, n * sizeof(float)));
  CHECK(cudaMalloc(&c_gpu, n * sizeof(float)));

  CHECK(cudaMemcpy(a_gpu, a, n * sizeof(float), cudaMemcpyHostToDevice));
  CHECK(cudaMemcpy(b_gpu, b, n * sizeof(float), cudaMemcpyHostToDevice));

  add<float><<<1, n>>>(a_gpu, b_gpu, c_gpu, n);

  CHECK(cudaMemcpy(c, c_gpu, n * sizeof(float), cudaMemcpyDeviceToHost));

  for (int i = 0; i < n; i++) {
    printf("%f ", c[i]);
  }
  printf("\n");

  cudaDeviceReset();
  return 0;
}
more >>

更多内容 >>

C++模板中的具体化和实例化

所谓具体化，就是使用具体的代码替换模板；而实例化，就是根据模板创建代码

  1. 显示具体化，从概念上看，具体化只有显示具体化这一种，语法template<> [返回值类型][函数名]([参数列表]);
  2. 显示实例化，语法template [返回值类型][函数名]([参数列表]);
  3. 隐式实例化，由编译器自动推导出来的
  4. 模板的声明和实现分离时，要注意进行显示实例化
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
#include <iostream>

template<typename T>
T add(T a, T b) {
  std::cout << "T:";
  return a + b;
}

template<>
float add(float a, float b) {
  std::cout << "F:";
  return a + b; // 显示具体化
}

template
double add(double a, double b); // 显示实例化


int main() {
  std::cout << add(1, 2) << std::endl;      // 隐式实例化
  std::cout << add(1.f, 2.f) << std::endl;  // 显示具体化
  std::cout << add(1.0, 2.0) << std::endl;  // 显示实例化
  return 0;
}

更多内容 >>

构造函数

C++中有很多中构造函数，比如无参构造函数、转换构造函数、拷贝构造函数、移动构造函数，还有赋值函数，下面的代码展示一下其中的区别。

一、代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
#include <iostream>

using namespace std;

template<class T>
class Pointer {
public:
  Pointer() : ptr(nullptr) {
    cout << "调用:无参构造函数" << endl;
  }

  Pointer(T *ptr) : ptr(ptr) {
    cout << "调用:转换构造函数" << endl;
  }

  Pointer(const Pointer &that) : ptr(that.ptr) {
    cout << "调用:拷贝构造函数" << endl;
  }

  Pointer(Pointer &&that) noexcept: ptr(that.ptr) {
    that.ptr = nullptr;
    cout << "调用:移动构造函数" << endl;
  }

  Pointer &operator=(const Pointer &that) {
    this->ptr = that.ptr;
    cout << "调用:赋值函数" << endl;
    return *this;
  }

private:
  T *ptr;

};

template<class T>
Pointer<T> test_p5(T *ptr) {
  Pointer<T> pointer = ptr;
  cout << &pointer << endl;
  return pointer;
}

template<class T>
Pointer<T> test_p6(T *ptr) {
  Pointer<T> pointer = ptr;
  cout << &pointer << endl;
  return std::move(pointer);
}

template<class T>
Pointer<T> &&test_p7(T *ptr) {
  Pointer<T> pointer = ptr;
  cout << &pointer << endl;
  return std::move(pointer);
}

template<class T>
Pointer<T> &&test_p8(T *ptr) {
  Pointer<T> pointer = ptr;
  cout << &pointer << endl;
  return std::move(pointer);
}

int main() {
  /*0.调用无参构造函数进行初始化*/
  cout << "************p0************" << endl;
  Pointer<float> p0;

  /*1.函数声明，而非变量声明*/
  cout << "************p1************" << endl;
  Pointer<float> p1();

  /*2.使用其他类型进行初始化时，调用转换构造函数*/
  cout << "************p2************" << endl;
  Pointer<float> p2 = new float[1024];

  /*3.调用拷贝构造函数*/
  cout << "************p3************" << endl;
  Pointer<float> p3 = p2;

  /*4.调用移动构造函数*/
  cout << "************p4************" << endl;
  Pointer<float> p4 = std::move(p2);

  /*5.编译器会进行优化，函数内的局部变量和函数返回的临时对象其实都是外部对象*/
  cout << "************p5************" << endl;
  Pointer<float> p5 = test_p5(new float[1024]);
  cout << &p5 << endl;

  /*6.调用移动构造函数初始化临时对象，而临时对象就是p6*/
  cout << "************p6************" << endl;
  Pointer<float> p6;
  p6 = test_p6(new float[1024]);
  cout << &p6 << endl;

  /*7.调用移动构造函数初始化p7*/
  cout << "************p7************" << endl;
  Pointer<float> p7;
  p7 = test_p7(new float[1024]);
  cout << &p7 << endl;

  /*8.调用移动构造函数初始化p8*/
  cout << "************p8************" << endl;
  Pointer<float> &&p8 = test_p8(new float[1024]);
  cout << &p8 << endl;

  return 0;
}

更多内容 >>

C++常见问题

1.如何减小so的体积

  1. 减少依赖库
  2. 移除符号表
  3. 压缩

2.如何减小模型的大小

  1. 剪枝
  2. 量化
  3. 压缩

3.量化的基本原理

  1. 量化的本质是数学变换，即线性变换
  2. 量化要注意精度

4.shared_ptr是线程安全的吗？

  1. 同一个shared_ptr被多个线程“读”是安全的
  2. 同一个shared_ptr被多个线程“写”是不安全的，但可以通过原子函数完成
  3. 共享引用计数的不同shared_ptr被多个线程“写”是安全的

更多内容 >>

C++可调用对象

C++中都有哪些可调用对象

  1. 函数/函数指针
  2. lambda表达式
  3. 重载了()运算符后的对象
  4. std::bind的返回值
  5. 所有可调用对象都可以被相应的std::function所引用
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
#include <iostream>
#include <functional>

using namespace std;

int add(int a, int b) { return a + b; }

class Sub {
public:
  int operator()(int a, int b) { return a - b; }
};

int main() {
  function<int(int, int)> func;

  func = add;
  cout << func(1, 2) << endl;

  Sub sub;
  func = sub;
  cout << func(1, 2) << endl;

  func = [](int a, int b) { return a * b; };
  cout << func(1, 2) << endl;

  func = bind([](int a, int b) { return a / b; }, 1, 2);
  cout << func(1, 2) << endl;

  return 0;
}

更多内容 >>

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

真正使人进步的,是不断总结。