1

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

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

然而，随着时间的推移，指针会丢失其中一些的内存地址，或者对它的引用，或者它指向的内存要么被释放，要么仅用于其他一些变量。然后这会导致应该运行的进程只是暂停并等待平台安排它，这永远不会发生，因为队列中的元素不再引用进程（我们使用文件描述符处理）。有没有办法防止这种情况发生？？

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

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);
}

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

4

1 回答 1

0

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

试试这里提到的产品之一： http ://en.wikipedia.org/wiki/BoundsChecker

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

于 2013-07-25T23:43:53.653 回答