カテゴリー: c++

fn main() {

  println!("Hello, world!");

}

$ valgrind ls -l
==10251== Memcheck, a memory error detector
==10251== Copyright (C) 2002-2024, and GNU GPL'd, by Julian Seward et al.
==10251== Using Valgrind-3.23.0 and LibVEX; rerun with -h for copyright info
==10251== Command: ls -l
==10251== 
合計 3700
-rwxrwxr-x 1 hoge hoge 3780776  5月 12 12:37 main
-rw-rw-r-- 1 hoge hoge      44  5月 12 12:36 main.rs
==10251== 
==10251== HEAP SUMMARY:
==10251==     in use at exit: 20,365 bytes in 9 blocks
==10251==   total heap usage: 140 allocs, 131 frees, 109,770 bytes allocated
==10251== 
==10251== LEAK SUMMARY:
==10251==    definitely lost: 0 bytes in 0 blocks
==10251==    indirectly lost: 0 bytes in 0 blocks
==10251==      possibly lost: 0 bytes in 0 blocks
==10251==    still reachable: 20,365 bytes in 9 blocks
==10251==         suppressed: 0 bytes in 0 blocks
==10251== Rerun with --leak-check=full to see details of leaked memory
==10251== 
==10251== For lists of detected and suppressed errors, rerun with: -s
==10251== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)

#include <stdlib.h>
int main()
{
 char *x = new char[100];
 return 0;
}

% valgrind --tool=memcheck ./memory
==23180== Memcheck, a memory error detector
==23180== Copyright (C) 2002-2022, and GNU GPL'd, by Julian Seward et al.
==23180== Using Valgrind-3.23.0.GIT-lbmacos and LibVEX; rerun with -h for copyright info
==23180== Command: ./memory
==23180== 
--23180-- run: /usr/bin/dsymutil "./memory"
warning: no debug symbols in executable (-arch x86_64)
==23180== Syscall param map_with_linking_np(link_info) points to uninitialised byte(s)
==23180==    at 0x100067D2E: __map_with_linking_np (in /usr/lib/dyld)
==23180==    by 0x10001C88A: dyld4::setUpPageInLinkingRegions(dyld4::RuntimeState&, dyld4::Loader const*, unsigned long, unsigned short, unsigned short, bool, dyld3::Array const&, dyld3::Array const&) (in /usr/lib/dyld)
==23180==    by 0x10001C221: invocation function for block in dyld4::Loader::setUpPageInLinking(Diagnostics&, dyld4::RuntimeState&, unsigned long, unsigned long long, dyld3::Array const&) const (in /usr/lib/dyld)
==23180==    by 0x10001BF94: dyld4::Loader::setUpPageInLinking(Diagnostics&, dyld4::RuntimeState&, unsigned long, unsigned long long, dyld3::Array const&) const (in /usr/lib/dyld)
==23180==    by 0x10001CA08: dyld4::Loader::applyFixupsGeneric(Diagnostics&, dyld4::RuntimeState&, unsigned long long, dyld3::Array const&, dyld3::Array const&, bool, dyld3::Array const&) const (in /usr/lib/dyld)
==23180==    by 0x100022212: dyld4::JustInTimeLoader::applyFixups(Diagnostics&, dyld4::RuntimeState&, dyld4::DyldCacheDataConstLazyScopedWriter&, bool) const (in /usr/lib/dyld)
==23180==    by 0x100009DBC: dyld4::prepare(dyld4::APIs&, dyld3::MachOAnalyzer const*) (in /usr/lib/dyld)
==23180==    by 0x1000092FE: (below main) (in /usr/lib/dyld)
==23180==  Address 0x1048e7d00 is on thread 1's stack
==23180==  in frame #1, created by dyld4::setUpPageInLinkingRegions(dyld4::RuntimeState&, dyld4::Loader const*, unsigned long, unsigned short, unsigned short, bool, dyld3::Array const&, dyld3::Array const&) (???:)
==23180== 
==23180== 
==23180== HEAP SUMMARY:
==23180==     in use at exit: 9,441 bytes in 176 blocks
==23180==   total heap usage: 186 allocs, 10 frees, 10,173 bytes allocated
==23180== 
==23180== LEAK SUMMARY:
==23180==    definitely lost: 4,388 bytes in 135 blocks
==23180==    indirectly lost: 48 bytes in 1 blocks
==23180==      possibly lost: 600 bytes in 3 blocks
==23180==    still reachable: 4,405 bytes in 37 blocks
==23180==         suppressed: 0 bytes in 0 blocks
==23180== Rerun with --leak-check=full to see details of leaked memory
==23180== 
==23180== Use --track-origins=yes to see where uninitialised values come from
==23180== For lists of detected and suppressed errors, rerun with: -s
==23180== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 124 from 39)

[11/09/22 12:28:51] [ctello] [info] Finding Tello ...
[11/09/22 12:28:51] [ctello] [error] sendto: 22 (Invalid argument)
[11/09/22 12:28:52] [ctello] [error] sendto: 22 (Invalid argument)
[11/09/22 12:28:53] [ctello] [error] sendto: 22 (Invalid argument)

#include <iostream>
#include <utility>
#include <vector>

const int a_size = 1000000*100;

class home
{
    int* m_land;
    int* cp_land;

public:
    explicit home(int size)
        : m_land{new int[size] ()}{}
    
    ~home() { delete [] m_land;}

    home(home&& other);

    int* land() const { return m_land; }

    int* land_cp() const { return cp_land; }

    void copy()
    {
        cp_land = new int[a_size];
        for (int i = 0; i <= a_size; i++)
        {
            cp_land[i] = m_land[i];
        }
    }

    void v_copy()
    {
        std::vector v_int(a_size, 0);
        //std::vector vc_int(a_size);
        //std::copy(v_int.begin(), v_int.end(), vc_int.begin());
        std::vector vc_int = v_int;
    }

    void del()
    {
        delete [] cp_land;
    }
};

home::home(home&& other)
    : m_land{other.m_land}
{
    other.m_land = nullptr;
}


int main()
{
    std::chrono::system_clock::time_point  start, end;
    start = std::chrono::system_clock::now();

    home A{a_size};
    std::cout << "A\'s land address : " << A.land() << std::endl;

    A.copy();
    std::cout << "A\'s cp_land address : " << A.land_cp() << std::endl;
    A.del();

    home B{std::move(A)};
    std::cout << "B\'s land address : " << B.land() << std::endl;

    B.v_copy();

    std::cout << std::endl;
    end = std::chrono::system_clock::now();
    double elapsed = std::chrono::duration_cast(end-start).count();
    std::cout << "elapsed time : " << elapsed << " ms" << std::endl;
}

領域サイズ：100MB

<初期状態：マニュアル(new int[])で領域確保とコピー>
A's land address : 0x7fad25700000
A's cp_land address : 0x7fad05700000
B's land address : 0x7fad25700000

elapsed time : 497 ms


<領域確保：おそらく0埋めされるはず>
A's land address : 0x7f8996700000
A's cp_land address : 0x7f8976700000
B's land address : 0x7f8996700000

elapsed time : 2292 ms


<領域初期化値を明示的に追加>
A's land address : 0x7f8549700000
A's cp_land address : 0x7f8529700000
B's land address : 0x7f8549700000

elapsed time : 2518 ms


<別のstd::vectorにコピー>
A's land address : 0x7fc174f00000
A's cp_land address : 0x7fc154f00000
B's land address : 0x7fc174f00000

elapsed time : 3510 ms


<コピーにstd::copyを使用>
A's land address : 0x7f8b68700000
A's cp_land address : 0x7f8b48700000
B's land address : 0x7f8b68700000

elapsed time : 4396 ms

#include <iostream>
#include <utility>

const long a_size = 1000000*100;

class home
{
    int* m_land;
    int* cp_land;

public:
    explicit home(long size)
        : m_land{new int[size] ()}{}
    
    ~home() { delete [] m_land;}

    home(home&& other);

    int* land() const { return m_land; }

    int* land_cp() const { return cp_land; }

    void copy()
    {
        cp_land = new int[a_size];
        for (int i = 0; i <= a_size; i++)
        {
            cp_land[i] = m_land[i];
        }
    }

    void del()
    {
        delete [] cp_land;
    }
};

home::home(home&& other)
    : m_land{other.m_land}
{
    other.m_land = nullptr;
}


int main()
{
    std::chrono::system_clock::time_point  start, end;
    start = std::chrono::system_clock::now();

    home A{a_size};
    std::cout << "A\'s land address : " << A.land() << std::endl;

    A.copy();
    std::cout << "A\'s cp_land address : " << A.land_cp() << std::endl;
    A.del();

    home B{std::move(A)};
    std::cout << "B\'s land address : " << B.land() << std::endl;

    std::cout << std::endl;
    end = std::chrono::system_clock::now();
    double elapsed = std::chrono::duration_cast(end-start).count();
    std::cout << "elapsed time : " << elapsed << " ms" << std::endl;
}

領域サイズ：100MB

<領域初期化有り>

・std::move
A's land address : 0x7ff049f00000
B's land address : 0x7ff049f00000

elapsed time : 166 ms

・+ 領域copy
A's land address : 0x7fb615700000
A's cp_land address : 0x7fb5f5700000
B's land address : 0x7fb615700000

elapsed time : 546 ms


<領域初期化無し>

・std::move
A's land address : 0x7fb23ff00000
B's land address : 0x7fb23ff00000

elapsed time : 0 ms

・+ 領域copy
A's land address : 0x7fb03df00000
A's cp_land address : 0x7fb01df00000
B's land address : 0x7fb03df00000

elapsed time : 514 ms

#include <iostream>
#include <mutex>
#include <thread>
#include <vector>
#include <cmath>

std::mutex mtx_;                // mutex for exclusive control
std::vector vec{};         // prime numbers array
int cal_int = 1;                // calc target integer
int max_int = 10000000;         // calc target max number
std::vector threads;       // array of threads
int num_thread = 12;                    // number of threads



void add_prime(int i)           // store the prime numberns in the vector
{
    std::lock_guard lock(mtx_);
    vec.push_back(i);
}

int get_int()                   // get the integer to be tested
{
    std::lock_guard lock(mtx_);
    ++cal_int;
    if (cal_int > 2 && cal_int%2 == 0)      // do not return an even number larger than four
    {
        ++cal_int;
    }
    return cal_int;
}

void ThreadA()
{
    while (true)
    {
        bool flag = false;
        int i = get_int();
        if (i > max_int)
        {
            break;
        }
        int sqt = sqrt(i);
        for (int j = 2; j <= sqt; ++j)
        {
            if (i%j == 0)
            {
                flag = true;
                break;
            }
        }
        if (flag != true)
        {
            add_prime(i);
        }
    }
}

int main()
{
    std::chrono::system_clock::time_point  start, end;
    start = std::chrono::system_clock::now();

    std::cout << std::endl;
    std::cout << "Hardware concurrency = " << std::thread::hardware_concurrency() << std::endl;

    for(size_t i=0; i < num_thread; ++i){
        threads.emplace_back(std::thread(ThreadA));
    }

    for(auto& thread : threads){
        thread.join();
    }

    std::cout << std::endl;
    std::cout << "Number of threads = " << num_thread << std::endl;

    std::cout << std::endl;
    end = std::chrono::system_clock::now();
    double elapsed = std::chrono::duration_cast(end-start).count();
    std::cout << "elapsed time : " << elapsed << " ms" << std::endl;

    std::cout << std::endl;
    std::cout << "number of prime numbers : " << vec.size() << std::endl;

    std::cout << std::endl;
    std::cout << "last five prime numbers" << std::endl;
    std::sort(vec.begin(), vec.end() );
    
    for (auto itr = (vec.end() - 5); itr != vec.end(); ++itr)
    {
        std::cout << *itr << std::endl;
    }

}

Hardware concurrency = 12

Number of threads = 12

elapsed time : 1358 ms

number of prime numbers : 664579

last five prime numbers
9999937
9999943
9999971
9999973
9999991