[CUDA] segmentation fault

#include "C_primes_search.h"
#include "kernel.cuh"
#include <vcruntime_new.h>

void C_primes_search::run() {
    divisors_read();
    last_num_read();
    data_flow.seekp( 0, data_flow.end );
    for( unsigned __int64 cycle = 0; cycle < num_of_cycles; cycle++ ) {
        cout << "<----------------->" << endl;
        cout << "Cykl numer " << cycle << endl;
        beg_t = clock();
        cuda_kernel_launch();
        end_t = clock() - beg_t;
        file_save();
        cout << "Zakres: " << last_num << " - ";
        last_num += num_of_blocks * size_of_block * 500000;
        cout << last_num - 1 << endl;
        cout << "Znalezionych liczb pierwszych: " << primes_per_cycle << endl;
        cout << "Czas cyklu: " << static_cast < double >( end_t ) / CLOCKS_PER_SEC << endl;
        cout << "Czas rzeczywisty: " << static_cast < double >( end_t ) * 1000000 /( primes_per_cycle * CLOCKS_PER_SEC ) << endl;
    }
}

void C_primes_search::operator delete[]( void * ptr ) {
    cudaFree( ptr );
}

void C_primes_search::nullptr_check( void * ptr, int line ) {
    if( ptr == nullptr ) {
        cout << "nullptr - linia: " << line << endl;
    }
}

void * C_primes_search::operator new[]( size_t size ) {
    void * ptr;
    cudaMallocManaged(( void ** ) & ptr, size );
    return ptr;
}

void C_primes_search::cuda_kernel_launch() {
    check_for_cuda_error( cudaSetDevice( 0 ), __LINE__ );
    check_for_cuda_error( cudaDeviceReset(), __LINE__ );
    primes_search_kernel << < num_of_blocks, size_of_block >> >( // tu zaczyna się seria błędów
    num_of_nums_to_check,
    divisors_arr_size,
    primes_arr_size,
    size_of_block,
    last_num,
    divisors_arr,
    primes_arr,
    primes_num );
    check_for_cuda_error( cudaDeviceSynchronize(), __LINE__ );
}

void C_primes_search::check_for_cuda_error( cudaError_t state, int line ) {
    if( state != cudaSuccess ) {
        cout << "Cuda error - linia " << line << " - " << cudaGetErrorString( state ) << endl;
    }
}

void C_primes_search::file_save() {
    primes_per_cycle = 0;
    for( unsigned __int64 index = 0; index < num_of_blocks * size_of_block; index++ ) {
        primes_per_cycle += primes_num[ index ];
        data_flow.write(( char * ) primes_arr[ index * primes_arr_size ], primes_num[ index ] * sizeof( unsigned __int64 ) );
    }
}

void C_primes_search::last_num_read() {
    data_flow.seekg( - 8, data_flow.end );
    data_flow.read(( char * ) & last_num, sizeof( last_num ) );
    last_num++;
}

C_primes_search::C_primes_search() {
    nullptr_check( primes_num = new unsigned __int64[ num_of_blocks * size_of_block ], __LINE__ );
    nullptr_check( divisors_arr = new unsigned __int64[ num_of_blocks * divisors_arr_size ], __LINE__ );
    nullptr_check( primes_arr = new unsigned __int64[ num_of_blocks * size_of_block * primes_arr_size ], __LINE__ );
    data_flow.open( "pierwsze.bin", ios::binary | ios::in | ios::out | ios::app | ios::ate );
    if( !data_flow.is_open() ) {
        throw "Plik pierwsze.bin nie otworzyl sie";
    }
    cout << "<----------------->" << endl;
    cout << "Podaj liczbe cykli: ";
    cin >> num_of_cycles;
}

void C_primes_search::divisors_read() {
    for( unsigned __int64 blockID = 0; blockID < num_of_blocks; blockID++ ) {
        data_flow.seekg( 0, data_flow.beg );
        data_flow.read(( char * ) & divisors_arr[ blockID * divisors_arr_size ], divisors_arr_size * sizeof( unsigned __int64 ) );
    }
}

C_primes_search::~C_primes_search() {
    data_flow.close();
    delete[] divisors_arr;
    delete[] primes_arr;
    delete[] primes_num;
}