Question

我有一个项目，包含在不同计算机上运行的多个进程。它类似于“OS模拟器”，主要是任务调度和资源分配。

有一个主要流程“平台”或“服务器”，它通过使用具有可以执行的可用流程的队列来规划/调度连接到它的不同流程。

然而，随着时间的推移，指针会丢失其中某些指针的内存地址，或者指向它的引用，或指向它的内存被释放或仅用于某些其他变量。然后，这会导致进程暂停，并等待平台调度它，这从未发生过，因为队列中的元素不再引用进程（我们使用文件描述符处理）。反正有没有阻止这种情况发生？

以下是我们认为问题所在的代码部分：

response = string_substring_from(response, sizeof(FREERESC));

char** data = string_split(response, COMA);

t_queue *temporaryQueue = queue_create();
t_scheduler_queue *queues = dictionary_get(levels_queues, data[0]);

pthread_mutex_lock(queues->mutex);

t_queue *anotherQueue = queue_create();

long o = 0;

if (queue_size(queues->character_queue) > 0)
{
    log_info(log, "Mas de un personaje listo");

    for (o = 0; o < queue_size(queues->character_queue); o++)
    {
        personaje_planificador *personajeEnLista = queue_pop(
        queues->character_queue);
        personaje_planificador *nuevoPersonaje = (personaje_planificador*) malloc(sizeof(personaje_planificador));
        // long *hola = (long*) malloc(sizeof(long));
        // memcpy(hola, &(personajeEnLista->fd), sizeof(long));
        // nuevoPersonaje->fd = hola;
        nuevoPersonaje->fd = personajeEnLista->fd;
        nuevoPersonaje->nombre = string_from_format("%s", personajeEnLista->nombre);
        queue_push(anotherQueue, nuevoPersonaje);
    }
}

char** simbolos;

long j = 2;
t_dictionary *recursosDisponibles = dictionary_create();

for (j = 2; j < list_size(queues->simbolos) + 2; j++)
{
    simbolos = string_split(data[j], DOSPUNTOS);
    long *temporary = (long*) malloc(sizeof(long));
    *temporary = atoi(simbolos[1]);
    dictionary_put(recursosDisponibles, simbolos[0], temporary);
}

if (queue_size(queues->blocked_queue) > 0)
{
    log_info(log, "Mas de un personaje bloqueado");

    long i = 0;
    long k = 0;
    for (i = 0; i < queue_size(queues->blocked_queue); i++)
    {
        blocked_character *blockedCharacter = queue_pop(queues->blocked_queue);

        for (k = 0; k < list_size(queues->simbolos); k++)
        {
            if (blockedCharacter->recurso == ((char*) list_get(queues->simbolos, k))[0])
            {
                if (giveResource(queues, dictionary_get(recursosDisponibles, list_get(queues->simbolos, k)), blockedCharacter) == 1)
                {
                    personaje_planificador *nuevoPersonajeAgain = (personaje_planificador*) malloc(sizeof(personaje_planificador));
                    nuevoPersonajeAgain->fd =
                    blockedCharacter->personaje->fd;
                    nuevoPersonajeAgain->nombre = blockedCharacter->personaje->nombre;
                    queue_push(temporaryQueue, nuevoPersonajeAgain);

                    //TODO log
                }
                else
                {
                    queue_push(queues->blocked_queue, blockedCharacter);
                }
            }
        }

        k = 0;
    }
}

o = 0;

for (o = 0; o < queue_size(temporaryQueue); o++)
{
    queue_push(anotherQueue, queue_pop(temporaryQueue));
}

queues->character_queue = anotherQueue;

pthread_mutex_unlock(queues->mutex);

t_level_address *addresses = (t_level_address*) dictionary_get(levelsMap, data[0]);

char **levelSocket = string_split(addresses->nivel, DOSPUNTOS);

long fdNivel = openSocketClient(levelSocket[1], levelSocket[0]);

sendMessage(fdNivel, stringRecursos(queues->simbolos, recursosDisponibles, atoi(data[1])));

free(recursosDisponibles);

log_info(log, "Liberar recursos.");

if (flagTerminoUnPersonaje == TRUE)
{
    executeKoopa(niveles, levels_queues, orquestador_config);
}

让我知道代码的一部分是否不清楚（它有一些用西班牙语写的东西），或者如果您需要另一个部分，您认为问题可能存在。

Answer 1

有人在其中一条评论中提及“ValGrind”。

尝试此处提及的产品之一：http://en.wikipedia.org/wiki/BoundsChecker

如果不是完全免费版本，您应该能够找到免费试用版。（自从我经常维护其他人的C并且不得不使用Purify和Insure来追捕这种混叠和泄漏时，已经过去了大约10年）

程序在进展时会丢失内存引用

1 个答案: