DEV Community: Gapry

Convert the endianness in C++ and test it with GDB and Python

Gapry — Thu, 09 Jul 2020 15:19:47 +0000

Introduction

As we know the network byte order use big endian and the x86 family processors use little endian. So, we need to convert them.

Implementation

Here, it's one of the implementation. The idea is that we use the binary operation to rearrange the byte order.

auto little_to_big(int32_t num) -> int32_t {
  return (num >> 24 & 0x000000FF) ^ 
         (num >> 8  & 0x0000FF00) ^ 
         (num << 8  & 0x00FF0000) ^ 
         (num << 24 & 0xFF000000);
}

auto m = int32_t(0x12345678);
auto n = little_to_big(m);

Testing

In GDB, we can easily observe the byte order. Set the break point, run it, assign the format and print it.

(gdb) break main
(gdb) run
(gdb) next
(gdb) next
(gdb) p/x m
(gdb) p/x n

We can use Python with GDB and make the testing more flexible.

import gdb

if __name__ == '__main__':
  gdb.execute('break main')
  gdb.execute('run')
  gdb.execute('next')
  gdb.execute('next')
  gdb.execute('p/x m')
  gdb.execute('p/x n')

And then, we can do a little bit code refactoring.

import gdb

def config():
  cmd = ['break main',
         'run'];
  list(map(gdb.execute, cmd))

def trace():
  cmd = ['next',
         'next',
         'p/x m',
         'p/x n']
  list(map(gdb.execute, cmd))

if __name__ == '__main__':
  config()
  trace()

Thank you for reading, see you next time.

References

What's unique pointer in C++

Gapry — Wed, 08 Jul 2020 12:28:33 +0000

Introduction

You need to manage the memory usage in the C++ world. If you allocate one object, you need to destroy it. For example:

auto pt = new point<float>(1.2f, 2.3f, 3.4f, 4.5f);
std::cout << *pt << std::endl;
delete pt;

You can enable the flag -fsanitize=address to detect the memory leaks. For example, if you forget to delete the object like this,

auto pt = new point<float>(1.2f, 2.3f, 3.4f, 4.5f);
std::cout << *pt << std::endl;

you will see the similar error message as following.

==2104860==ERROR: LeakSanitizer: detected memory leaks

Direct leak of 16 byte(s) in 1 object(s) allocated from

std::unique_ptr

To avoid the situation, it's easy in the modern C++, just use the std::unique_ptr.

auto pt = std::unique_ptr<point<float>>(new point<float>(1.2f, 2.3f, 3.4f, 4.5f));

Implement your own unique pointer

The theory of unique pointer isn't difficult, here is one of Implementation.

template <class T>
class unique_ptr {
  T* m_ptr = nullptr;

public:
  explicit unique_ptr(T* ptr) : m_ptr(ptr) {
  }

  ~unique_ptr() {
    if (m_ptr) {
      delete m_ptr;
    }   
    m_ptr = nullptr;
  }

  auto operator*() const -> T { 
    return *m_ptr;
  }
};

Thank you for reading, see you next time.

References

Multithreading in C++

Gapry — Tue, 07 Jul 2020 15:26:25 +0000

Introduction

Previously I've introduced the lambda expression in C++, I'll show a example how to use lambda expression in the multithreading. If you don't read it, here is link.

In the post, I will introduce three concept of multithreading and use an example to show how to do it in C++ Programming. The example is the random ten points generation.

Create Thread
Join
Lock

Create Thread

To create a thread, we have two methods to achieve. One is the following code snippet.

auto task(float x, float y, float z) -> void {
  ...
}
auto worker = std::thread(task, x, y);

Other is the lambda expression.

auto worker = std::thread(
  [](float x, float y, float z) { ... }, 
  arg1, 
  arg2);

If you need to create a set of threads at the same time, you can utilize the std::vector.

auto spawn(void) -> std::vector<std::thread> {
  auto workers = std::vector<std::thread>();
  workers.emplace_back(
    [](float x, float y, float z) { ... }, 
    x, y, z);
  return workers;
}

auto workers = spawn();

Join

Once we create the threads, the thread-join is easy.

auto workers = spawn();
for (auto& worker : workers) {
  worker.join();  
}

Lock

We need to output the point(x, y, z) to the terminal.

workers.emplace_back(
  [](float x, float y, float z) { 
    std::cout << "(" << x << ", " << y << ", " << z << ")";
  }, 
  x, y, z);

But, you will find the output is not the same for each time. To fix the issue, we can utilize std::mutex.

std::mutex mtx;

workers.emplace_back(
  [](float x, float y, float z) { 
    mtx.lock();
    std::cout << "(" << x << ", " << y << ", " << z << ")";
    mtx.unlock();
  }, 
  x, y, z);

Thank you for reading, see you next time.

References

Introduce C++ Lambda

Gapry — Sat, 04 Jul 2020 23:47:36 +0000

Introduction

I will show three concepts of C++ Lambda in the blog post.

Subroutine
Capture by value
Capture by reference

Subroutine

We cannot define a routine in any existing routine.

void f(void) {
  int sum(int x, int y) {
    return x + y;
  }
}

So, we need the lambda expression. Let's rewrite the code as following.

void f(void) {
  auto sum = [](int x, int y) -> int {
    return x + y;
  };
}

Capture by value

One of the C++ Lambda features calls Capture, here is the example usage.

void f(void) {
  auto sum = [s = 1](int x, int y) -> int {
    return (x + y) << s;
  };
}

As you can see it likes function parameters, it's the capture by value.

Capture by reference

Typically, we have the call-by-value and call-by-reference in Computer Science. Just like that, we have the capture by value and capture by reference in C++.

void f(void) {
  auto s   = int(1);
  auto sum = [&](int x, int y) -> int {
    return (x + y) << s;
  };
}

The benefit of the capture by reference is that can avoid the coping overhead.

Thank you for reading, see you next time.