История изменений

Исправление Tumyq, 20.11.19 14:16 (текущая версия) :

похоже, я что-то намудрил.


#include "thread_pool/ctpl.h"

struct HFREntry_par {   
    std::string fname_in;
    std::string fname_out;
    unsigned int block_size;
};

    static fs::ifstream *f_in;
    static fs::ofstream *f_out;
    static ctpl::thread_pool *t_pool; 
    static std::mutex mtx, mtx2, mtx3;   

    static size_t f_size = 0, block_size = 0;   

void MT_HFReaderImpl::init_f(const HFREntry_par &vars)
{
    std::string path = vars.fname_in;
    if (!fs::exists(path) || !fs::is_regular_file(path)) return;
    block_size = vars.block_size;
    f_in = new fs::ifstream(path, std::ios::binary | std::ios::ate); //файл на чтение
    f_size = static_cast<size_t>(f_in->tellg()) + 1; //размер файла
    f_in->seekg(0);
    f_out = new fs::ofstream(vars.fname_out, std::ios::binary); //файл на запись
    int core_n = static_cast<int>(std::thread::hardware_concurrency()); //заряжаем пул
    t_pool = new ctpl::thread_pool(core_n);
}

void MT_HFReaderImpl::loop_f()
{
     //сколько целых блоков и остаток
    if ( f_size <= 0 || block_size <= 0 ) return;

    auto reader = [&]
    {
        if (f_in == nullptr || f_out == nullptr || t_pool == nullptr) return;

        std::string buffer(unsigned(block_size), '\0'); // Буфер
        std::hash<std::string> hash_fn;

        {
            // Начинаем чтение, другие треды ждут
            std::unique_lock<std::mutex> lock(mtx);

            // Читаем в буфер
            if (f_size < block_size){
                block_size = f_size;
            }

            f_in->read(&buffer[0],int(block_size));

            f_size -= block_size;
            if(f_size <= 0){
                finish();
            }
        }

        // Обрабатываем данные
        size_t _hash = hash_fn(buffer);

        {
            // Пишем в выходной файл, другие треды ждут
            std::unique_lock<std::mutex> lock(mtx2);

            *f_out << std::to_string(_hash) + "\n";

            std::cout << "hash:" << _hash << '\n';
        }
    };

    while (!f_in->eof()){
        t_pool->push([&] (int id) { reader(); });
    }
}

void MT_HFReaderImpl::finish()
{
    std::unique_lock<std::mutex> lock(mtx3);
    f_in->close();
    delete f_in;
    f_in = nullptr;
    f_out->close();
    delete f_out;
    f_out = nullptr;
    delete t_pool;
    t_pool = nullptr;
}

void MT_HFReaderImpl::file_read( const HFREntry_par & vars )
{
    init_f(vars);
    loop_f();
}

int main(int argc, char *argv[])
{
    HFREntry_par vars;

    vars.fname_in = "input_file_name.txt";
    vars.fname_out = "output_file_name.txt";
    vars.block_size = 1024 * 1024;

    file_read( vars );
}

Исправление Tumyq, 20.11.19 14:13:

похоже, я что-то намудрил.


#include "thread_pool/ctpl.h"

struct HFREntry_par {   
    std::string fname_in;
    std::string fname_out;
    unsigned int block_size;
};

    static fs::ifstream *f_in;
    static fs::ofstream *f_out;
    static ctpl::thread_pool *t_pool;    

    static size_t f_size = 0, block_size = 0;   

void MT_HFReaderImpl::init_f(const HFREntry_par &vars)
{
    std::string path = vars.fname_in;
    if (!fs::exists(path) || !fs::is_regular_file(path)) return;
    block_size = vars.block_size;
    f_in = new fs::ifstream(path, std::ios::binary | std::ios::ate); //файл на чтение
    f_size = static_cast<size_t>(f_in->tellg()) + 1; //размер файла
    f_in->seekg(0);
    f_out = new fs::ofstream(vars.fname_out, std::ios::binary); //файл на запись
    int core_n = static_cast<int>(std::thread::hardware_concurrency()); //заряжаем пул
    t_pool = new ctpl::thread_pool(core_n);
}

void MT_HFReaderImpl::loop_f()
{
     //сколько целых блоков и остаток
    if ( f_size <= 0 || block_size <= 0 ) return;

    auto reader = [&]
    {
        if (f_in == nullptr || f_out == nullptr || t_pool == nullptr) return;

        std::string buffer(unsigned(block_size), '\0'); // Буфер
        std::hash<std::string> hash_fn;

        {
            // Начинаем чтение, другие треды ждут
            std::unique_ptr<std::mutex> lock(new std::mutex);

            // Читаем в буфер
            if (f_size < block_size){
                block_size = f_size;
            }

            f_in->read(&buffer[0],int(block_size));

            f_size -= block_size;
            if(f_size <= 0){
                finish();
            }
        }

        // Обрабатываем данные
        size_t _hash = hash_fn(buffer);

        {
            // Пишем в выходной файл, другие треды ждут
            std::unique_ptr<std::mutex> lock(new std::mutex);

            *f_out << std::to_string(_hash) + "\n";

            std::cout << "hash:" << _hash << '\n';
        }
    };

    while (!f_in->eof()){
        t_pool->push([&] (int id) { reader(); });
    }
}

void MT_HFReaderImpl::finish()
{
    std::unique_ptr<std::mutex> lock(new std::mutex);
    f_in->close();
    delete f_in;
    f_in = nullptr;
    f_out->close();
    delete f_out;
    f_out = nullptr;
    delete t_pool;
    t_pool = nullptr;
}

void MT_HFReaderImpl::file_read( const HFREntry_par & vars )
{
    init_f(vars);
    loop_f();
}

int main(int argc, char *argv[])
{
    HFREntry_par vars;

    vars.fname_in = "input_file_name.txt";
    vars.fname_out = "output_file_name.txt";
    vars.block_size = 1024 * 1024;

    file_read( vars );
}

Исправление Tumyq, 20.11.19 14:10:

похоже, я что-то намудрил.


#include "thread_pool/ctpl.h"

struct HFREntry_par {   
    std::string fname_in;
    std::string fname_out;
    unsigned int block_size;
};

    static fs::ifstream *f_in;
    static fs::ofstream *f_out;
    static ctpl::thread_pool *t_pool;    

    static size_t f_size = 0, block_size = 0;   

void MT_HFReaderImpl::init_f(const HFREntry_par &vars)
{
    std::string path = vars.fname_in;
    if (!fs::exists(path) || !fs::is_regular_file(path)) return;
    block_size = vars.block_size;
    f_in = new fs::ifstream(path, std::ios::binary | std::ios::ate); //файл на чтение
    f_size = static_cast<size_t>(f_in->tellg()) + 1; //размер файла
    f_in->seekg(0);
    f_out = new fs::ofstream(vars.fname_out, std::ios::binary); //файл на запись
    int core_n = static_cast<int>(std::thread::hardware_concurrency()); //заряжаем пул
    t_pool = new ctpl::thread_pool(core_n);
}

void MT_HFReaderImpl::loop()
{
     //сколько целых блоков и остаток
    if ( f_size <= 0 || block_size <= 0 ) return;

    auto reader = [&]
    {
        if (f_in == nullptr || f_out == nullptr || t_pool == nullptr) return;

        std::string buffer(unsigned(block_size), '\0'); // Буфер
        std::hash<std::string> hash_fn;

        {
            // Начинаем чтение, другие треды ждут
            std::unique_ptr<std::mutex> lock(new std::mutex);

            // Читаем в буфер
            if (f_size < block_size){
                block_size = f_size;
            }

            f_in->read(&buffer[0],int(block_size));

            f_size -= block_size;
            if(f_size <= 0){
                finish();
            }
        }

        // Обрабатываем данные
        size_t _hash = hash_fn(buffer);

        {
            // Пишем в выходной файл, другие треды ждут
            std::unique_ptr<std::mutex> lock(new std::mutex);

            *f_out << std::to_string(_hash) + "\n";

            std::cout << "hash:" << _hash << '\n';
        }
    };

    while (!f_in->eof()){
        t_pool->push([&] (int id) { reader(); });
    }
}

void MT_HFReaderImpl::finish()
{
    std::unique_ptr<std::mutex> lock(new std::mutex);
    f_in->close();
    delete f_in;
    f_in = nullptr;
    f_out->close();
    delete f_out;
    f_out = nullptr;
    delete t_pool;
    t_pool = nullptr;
}

void MT_HFReaderImpl::file_read( const HFREntry_par & vars )
{
    init_f(vars);
    loop();
}

int main(int argc, char *argv[])
{
    HFREntry_par vars;

    vars.fname_in = "input_file_name.txt";
    vars.fname_out = "output_file_name.txt";
    vars.block_size = 1024 * 1024;

    file_read( vars );
}

Исправление Tumyq, 20.11.19 14:08:

похоже, я что-то намудрил.


#include "thread_pool/ctpl.h"

struct HFREntry_par {   
    std::string fname_in;
    std::string fname_out;
    unsigned int block_size;
};

    static fs::ifstream *f_in;
    static fs::ofstream *f_out;
    static ctpl::thread_pool *t_pool;    

    static size_t f_size = 0, block_size = 0;   

void MT_HFReaderImpl::init_f(const HFREntry_par &vars)
{
    std::string path = vars.fname_in;
    if (!fs::exists(path) || !fs::is_regular_file(path)) return;
    block_size = vars.block_size;
    f_in = new fs::ifstream(path, std::ios::binary | std::ios::ate); //файл на чтение
    f_size = static_cast<size_t>(f_in->tellg()) + 1; //размер файла
    f_in->seekg(0);
    f_out = new fs::ofstream(vars.fname_out, std::ios::binary); //файл на запись
    int core_n = static_cast<int>(std::thread::hardware_concurrency()); //заряжаем пул
    t_pool = new ctpl::thread_pool(core_n);
}

void MT_HFReaderImpl::loop()
{
     //сколько целых блоков и остаток
    if ( f_size <= 0 || block_size <= 0 ) return;

    auto reader = [&]
    {
        if (f_in == nullptr || f_out == nullptr || t_pool == nullptr) return;

        std::string buffer(unsigned(block_size), '\0'); // Буфер
        std::hash<std::string> hash_fn;

        {
            // Начинаем чтение, другие треды ждут
            std::unique_ptr<std::mutex> lock(new std::mutex);

            // Читаем в буфер
            if (f_size < block_size){
                block_size = f_size;
            }

            f_in->read(&buffer[0],int(block_size));

            f_size -= block_size;
            if(f_size <= 0){
                finish();
            }
        }

        // Обрабатываем данные
        size_t _hash = hash_fn(buffer);

        {
            // Пишем в выходной файл, другие треды ждут
            std::unique_ptr<std::mutex> lock(new std::mutex);

            *f_out << std::to_string(_hash) + "\n";

            std::cout << "hash:" << _hash << '\n';
        }
    };

    while (!f_in->eof()){
        t_pool->push([&] (int id) { reader(); });
    }
}

void MT_HFReaderImpl::finish()
{
    std::unique_ptr<std::mutex> lock(new std::mutex);
    f_in->close();
    delete f_in;
    f_in = nullptr;
    f_out->close();
    delete f_out;
    f_out = nullptr;
    delete t_pool;
    t_pool = nullptr;
}

void MT_HFReaderImpl::file_read( const HFREntry_par & vars )
{
    init_f(vars);
    loop();
}

int main(int argc, char *argv[])
{
    HFREntry_par vars;

    vars.fname_in = "input_file_name.txt";
    vars.fname_out = "output_file_name.txt";
    vars.block_size = 1024 * 1024;

    file_read( vars );


}

Исправление Tumyq, 20.11.19 14:07:

похоже, я что-то намудрил.


#include "thread_pool/ctpl.h"

struct HFREntry_par {   
    std::string fname_in;
    std::string fname_out;
    unsigned int block_size;
};

    static fs::ifstream *f_in;
    static fs::ofstream *f_out;
    static ctpl::thread_pool *t_pool;    

    static size_t f_size = 0, block_size = 0;   

void MT_HFReaderImpl::init_f(const HFREntry_par &vars)
{
    std::string path = vars.fname_in;
    if (!fs::exists(path) || !fs::is_regular_file(path)) return;
    block_size = vars.block_size;
    f_in = new fs::ifstream(path, std::ios::binary | std::ios::ate); //файл на чтение
    f_size = static_cast<size_t>(f_in->tellg()) + 1; //размер файла
    f_in->seekg(0);
    f_out = new fs::ofstream(vars.fname_out, std::ios::binary); //файл на запись
    int core_n = static_cast<int>(std::thread::hardware_concurrency()); //заряжаем пул
    t_pool = new ctpl::thread_pool(core_n);
}

void MT_HFReaderImpl::loop()
{
     //сколько целых блоков и остаток
    if ( f_size <= 0 || block_size <= 0 ) return;

    auto reader = [&]
    {
        if (f_in == nullptr || f_out == nullptr || t_pool == nullptr) return;

        std::string buffer(unsigned(block_size), '\0'); // Буфер
        std::hash<std::string> hash_fn;

        {
            // Начинаем чтение, другие треды ждут
            std::unique_ptr<std::mutex> lock(new std::mutex);

            // Читаем в буфер
            if (f_size < block_size){
                block_size = f_size;
            }

            f_in->read(&buffer[0],int(block_size));

            f_size -= block_size;
            if(f_size <= 0){
                finish();
            }
        }

        // Обрабатываем данные
        size_t _hash = hash_fn(buffer);

        {
            // Пишем в выходной файл, другие треды ждут
            std::unique_ptr<std::mutex> lock(new std::mutex);

            *f_out << std::to_string(_hash) + "\n";

            std::cout << "hash:" << _hash << '\n';
        }
    };

    while (!f_in->eof()){
        t_pool->push([&] (int id) { reader(); });
    }
}

void MT_HFReaderImpl::finish()
{
    std::unique_ptr<std::mutex> lock(new std::mutex);
    f_in->close();
    delete f_in;
    f_in = nullptr;
    f_out->close();
    delete f_out;
    f_out = nullptr;
    delete t_pool;
    t_pool = nullptr;
}

void MT_HFReaderImpl::file_read( const HFREntry_par & vars )
{
    init_f(vars);
    loop();
}

int main(int argc, char *argv[])
{
HFREntry_par vars;

 vars.fname_in = "input_file_name.txt";
    vars.fname_out = "output_file_name.txt";
    vars.block_size = 1024 * 1024;

file_read( vars );


}

Исправление Tumyq, 20.11.19 14:07:

похоже, я что-то намудрил.


#include "thread_pool/ctpl.h"

struct HFREntry_par {   
    std::string fname_in;
    std::string fname_out;
    unsigned int block_size;
};

    static fs::ifstream *f_in;
    static fs::ofstream *f_out;
    static ctpl::thread_pool *t_pool;    

    static size_t f_size = 0, block_size = 0;
    static atomic<size_t> bl_cnt { 0 };

void MT_HFReaderImpl::init_f(const HFREntry_par &vars)
{
    std::string path = vars.fname_in;
    if (!fs::exists(path) || !fs::is_regular_file(path)) return;
    block_size = vars.block_size;
    f_in = new fs::ifstream(path, std::ios::binary | std::ios::ate); //файл на чтение
    f_size = static_cast<size_t>(f_in->tellg()) + 1; //размер файла
    f_in->seekg(0);
    f_out = new fs::ofstream(vars.fname_out, std::ios::binary); //файл на запись
    int core_n = static_cast<int>(std::thread::hardware_concurrency()); //заряжаем пул
    t_pool = new ctpl::thread_pool(core_n);
}

void MT_HFReaderImpl::loop()
{
     //сколько целых блоков и остаток
    if ( f_size <= 0 || block_size <= 0 ) return;

    auto reader = [&]
    {
        if (f_in == nullptr || f_out == nullptr || t_pool == nullptr) return;

        std::string buffer(unsigned(block_size), '\0'); // Буфер
        std::hash<std::string> hash_fn;

        {
            // Начинаем чтение, другие треды ждут
            std::unique_ptr<std::mutex> lock(new std::mutex);

            // Читаем в буфер
            if (f_size < block_size){
                block_size = f_size;
            }

            f_in->read(&buffer[0],int(block_size));

            f_size -= block_size;
            if(f_size <= 0){
                finish();
            }
        }

        // Обрабатываем данные
        size_t _hash = hash_fn(buffer);

        {
            // Пишем в выходной файл, другие треды ждут
            std::unique_ptr<std::mutex> lock(new std::mutex);

            *f_out << std::to_string(_hash) + "\n";

            std::cout << "hash:" << _hash << '\n';
        }
    };

    while (!f_in->eof()){
        t_pool->push([&] (int id) { reader(); });
    }
}

void MT_HFReaderImpl::finish()
{
    std::unique_ptr<std::mutex> lock(new std::mutex);
    f_in->close();
    delete f_in;
    f_in = nullptr;
    f_out->close();
    delete f_out;
    f_out = nullptr;
    delete t_pool;
    t_pool = nullptr;
}

void MT_HFReaderImpl::file_read( const HFREntry_par & vars )
{
    init_f(vars);
    loop();
}

int main(int argc, char *argv[])
{
HFREntry_par vars;

 vars.fname_in = "input_file_name.txt";
    vars.fname_out = "output_file_name.txt";
    vars.block_size = 1024 * 1024;

file_read( vars );


}

Исходная версия Tumyq, 20.11.19 14:06:

похоже, я что-то намудрил.


#include "thread_pool/ctpl.h"

struct HFREntry_par {   
    std::string fname_in;
    std::string fname_out;
    unsigned int block_size;
};

    static fs::ifstream *f_in;
    static fs::ofstream *f_out;
    static ctpl::thread_pool *t_pool;
    static std::mutex mtx, mtx2, mtx3;

    static size_t f_size = 0, block_size = 0;
    static atomic<size_t> bl_cnt { 0 };

void MT_HFReaderImpl::init_f(const HFREntry_par &vars)
{
    std::string path = vars.fname_in;
    if (!fs::exists(path) || !fs::is_regular_file(path)) return;
    block_size = vars.block_size;
    f_in = new fs::ifstream(path, std::ios::binary | std::ios::ate); //файл на чтение
    f_size = static_cast<size_t>(f_in->tellg()) + 1; //размер файла
    f_in->seekg(0);
    f_out = new fs::ofstream(vars.fname_out, std::ios::binary); //файл на запись
    int core_n = static_cast<int>(std::thread::hardware_concurrency()); //заряжаем пул
    t_pool = new ctpl::thread_pool(core_n);
}

void MT_HFReaderImpl::loop()
{
     //сколько целых блоков и остаток
    if ( f_size <= 0 || block_size <= 0 ) return;

    auto reader = [&]
    {
        if (f_in == nullptr || f_out == nullptr || t_pool == nullptr) return;

        std::string buffer(unsigned(block_size), '\0'); // Буфер
        std::hash<std::string> hash_fn;

        {
            // Начинаем чтение, другие треды ждут
            std::unique_ptr<std::mutex> lock(new std::mutex);

            // Читаем в буфер
            if (f_size < block_size){
                block_size = f_size;
            }

            f_in->read(&buffer[0],int(block_size));

            f_size -= block_size;
            if(f_size <= 0){
                finish();
            }
        }

        // Обрабатываем данные
        size_t _hash = hash_fn(buffer);

        {
            // Пишем в выходной файл, другие треды ждут
            std::unique_ptr<std::mutex> lock(new std::mutex);

            *f_out << std::to_string(_hash) + "\n";

            std::cout << "hash:" << _hash << '\n';
        }
    };

    while (!f_in->eof()){
        t_pool->push([&] (int id) { reader(); });
    }
}

void MT_HFReaderImpl::finish()
{
    std::unique_ptr<std::mutex> lock(new std::mutex);
    f_in->close();
    delete f_in;
    f_in = nullptr;
    f_out->close();
    delete f_out;
    f_out = nullptr;
    delete t_pool;
    t_pool = nullptr;
}

void MT_HFReaderImpl::file_read( const HFREntry_par & vars )
{
    init_f(vars);
    loop();
}

int main(int argc, char *argv[])
{
HFREntry_par vars;

 vars.fname_in = "input_file_name.txt";
    vars.fname_out = "output_file_name.txt";
    vars.block_size = 1024 * 1024;

file_read( vars );


}