Cuda: Место записи о нарушении прав доступа 0x0000000000000000

Question

Мой код:

int main() {

cudaError_t err = cudaSuccess;

FILE *fp2 = fopen("key.txt", "r");
size_t len = 256;
char *line = (char *)malloc(sizeof(char) * len);

int icount = 0;
char **m_keyword;
cudaMallocManaged(&m_keyword, len *550000 * sizeof(char *));
while (fgets(line, len, fp2) != NULL) {
    line[strlen(line) - 1] = '\0';

    err = cudaMallocManaged(&(m_keyword[icount]), sizeof(line) / sizeof(char *) * sizeof(char));

    if (err != cudaSuccess)
    {
        fprintf(stderr, "(error code %s)!\n", cudaGetErrorString(err));
    }
    strcpy(m_keyword[icount], line);    // Access violation writing location
    icount++;
}
free(line);

kern_2D << < 55000, 1 >> > (m_keyword, icount);
cudaDeviceSynchronize();

return 0;
}

Я пишу код для чтения текстового файла с таким содержанием:

motorcycle ckd
new apsonic
ckd 2017
ckd 2018
motorcycle apsonic
new motorcycle apsonic

Если я запускаю файл с 2000 строками, все в порядке.Но если я запускаю более 26000 строк, получаю случайное сообщение об ошибке «Адрес записи о нарушении доступа 0x0000000000000000».Что-то может работать, что-то получило ошибку.Пожалуйста, помогите мне.

Answer 1

Когда вы вызываете cudaMallocManaged() для выделения памяти для m_keyword[icount], вы используете sizeof(line) / sizeof(char*) * sizeof(char) для длины байта, что неверно (4/4 * 1 = 1 байт!).Вместо этого вам нужно использовать strlen(line)+1.

На самом деле, даже ваш первый вызов cudaMallocManaged() неверен.Вы не должны умножать количество char* указателей на len вообще.Вы выделяете в 256 раз больше байтов, чем вам действительно нужно.

При этом вы вообще не останавливаете свою программу, если cudaMallocManaged() (или что-то еще) не удается.И вам следует ограничить цикл while, чтобы icount не превышал количество char* указателей, для которых вы выделяете место.

Вместо этого попробуйте что-то вроде этого:

int main()
{    
    FILE *fp2 = fopen("key.txt", "r");
    if (!fp2)
    {
        fprintf(stderr, "Error opening file!\n");
        return 1;
    }

    const size_t max_lines = 55000; 
    const size_t max_line_len = 256;

    char line[max_line_len];
    size_t line_len;

    char **m_keyword = NULL;
    int icount = 0;

    cudaError_t err = cudaMallocManaged((void**)&m_keyword, max_lines * sizeof(char*));
    if (err != cudaSuccess)
    {
        fprintf(stderr, "Error allocating memory for m_keyword! %s\n", cudaGetErrorString(err));
        fclose(fp2);
        return 1;
    }

    do
    {
        if (!fgets(line, max_line_len, fp2))
        {
            if (ferror(fp2) && !feof(fp2))
            {
                fprintf(stderr, "Error reading from file!\n");
                fclose(fp2);
                return 1;
            }
            break;
        }

        line_len = strlen(line);
        if ((line_len > 0) && (line[line_len - 1] == '\n'))
        {
            line[line_len - 1] = '\0';
            --line_len;
        }

        err = cudaMallocManaged((void**)&(m_keyword[icount]), line_len + 1);
        if (err != cudaSuccess)
        {
            fprintf(stderr, "Error allocating memory for m_keyword[%d]! %s\n", icount, cudaGetErrorString(err));
            fclose(fp2);
            return 1;
        }

        strcpy(m_keyword[icount], line);
        ++icount;
    }
    while (icount < max_lines);

    fclose(fp2);

    kern_2D << < max_lines, 1 >> > (m_keyword, icount);
    cudaDeviceSynchronize();

    return 0;
}