Большая проблема эффективности. Tips, чтобы оптимизировать hash table в C?

Хорошие, я осуществляю алгоритм Greedy, чтобы красить grafos. grafos могут иметь даже 1 000 000 верхов. Все целые числа uint_32, и чтобы сохранять их, я использую hash table, который использует arrays динамические, чтобы решать столкновения (и ты не заносишь в список соединенные, потому что я прочитал, что, таким образом, оптимизируется).

Теоретически он был бы должен скроллировать алгоритм в минуты, но только загружать grafo отсрачивает меня час. Какая-то рекомендация? В коде я использую calloc вместо malloc из-за которого я прочитал, что для hash tables рекомендуется.

Ты я recomendas использовать malloc? Или возможно, что алгоритм очень неэффективный, из-за которого моя операционная система медленная (у Меня есть ubuntu 32 бита с 1 Gb ОЗУ).

Здесь я показываю код структур и как они создаются.

struct _tabla_type {
     uint32_t tamanho;
     elemento_t *tabla; //array dinamico de elemenot_t
};

//inicializar (n = numero de vertices)
tabla_type nuevatabla(uint32_t n) {
    assert(n > 0);
    size_t h = sizeStructelem(); // el tamaño de la structura correspondiente (esta en otro .c por lo que no la puedo acceder directamente)
    tabla_type table = NULL;
    table = calloc(1, sizeof( struct _tabla_type)) ;
    table->tamanho = n;
    table->tabla = calloc(n,  sizeof(h));
    for (uint32_t i = 0 ; i < table->tamanho; i++)
    {
     table->tabla[i] = NULL;
    }

    return table;
}

// Cada indice de la tabla anterior tiene un elemento de la sig
// estructura, que es un array de dinamicos de vertices que colisionaron
//por la funcion hash
struct _elemento_t{
    VerticeSt *array_vertex;
    uint32_t used;
    uint32_t size;
};

// agregar elemento 
elemento_t newElement(uint32_t vertice, uint32_t vecino, elemento_t b) {
    VerticeSt Vertice = NuevoVertice(vertice,vecino);
    if (b == NULL){
        b = calloc(1, sizeof(struct _elemento_t));
        b->array_vertex = calloc(1, sizeof(struct _VerticeSt));
        b->array_vertex[0] = Vertice;
        b->used = 1;
        b->size = 1;
    }
    else{
        if (b->used == b->size) {
            b->size *= 2;
            b->array_vertex = (VerticeSt *)realloc(b->array_vertex, b->size * sizeof(struct _VerticeSt));
      }
      b->array_vertex[b->used++] = Vertice;
  }
 return b;
}


// en los correspondientes .h esta typedef struct _tabla_type *tabla_type

// y typedef struct _elemnto_t *elemento_t
2
задан 05.04.2017, 15:15
1 ответ

Я думаю, что у тебя есть проблема, в котором ты делаешь миллионы просьб динамической памяти. (он кажется, что минимум 2 миллиона)

У тебя есть динамическая структура с очень маленькими но крайне многочисленными элементами.

В зависимости от хардвера, который опаздывает час, он мне кажется до небольшого количества времени.

Решение состоит в том, чтобы уменьшать просьбы динамической памяти, я ты не могу быть конкретнее, из-за которого мне не хватало бы кода осуществления, но я предпочел бы не делать просьбы памяти каждого из верхов. Или использовать статическую память или искать другое решение, но это разбито твой результат.

Помимо этого, если ты действительно хочешь скорость, ты был бы должен проверять использование сборщика SSE. Это способ получать максимальную скорость и я думаю, что для твоего случая ты мог бы быть в порядке.

Единственная проблема состоит в том, что ты должен ставить структуры памяти для того, чтобы они смогли использовать максимально скорость, но это уже будет другим вопросом :D

1
ответ дан 24.11.2019, 14:30