C++ (Cpp) memory_cache_free示例

示例#1

void dino_http_start(dino_http_site_t *dino_site) {
    if (NULL == dino_site) {
        fprintf(stderr, "[ERROR] The site is not defined..\n\r");
        return;
    }

    struct sockaddr_in sockaddr_client;
    socklen_t sockaddr_client_length = sizeof(sockaddr_client);
    memory_clear(&sockaddr_client, sockaddr_client_length);

    memory_cache_alloc(1024 * 16);

    g_server_socket = startup_connection(dino_site);

    if (-1 != g_server_socket) {
        fprintf(stdout, "[INFO] Dino has taking the stage on port %d\n\r", dino_site->port);

        while (g_dino_keep_running) {
            int client_socket = accept(g_server_socket, (struct sockaddr *) &sockaddr_client, &sockaddr_client_length);

            dino_process_request(dino_site, client_socket);
        }

        close(g_server_socket);
    }

    memory_cache_free();
}

示例#2

文件： splay_tree.c 项目： Incarnation-p-lee/libds

static inline void
splay_tree_destroy_i(s_splay_tree_t *tree)
{
    s_array_queue_t *queue;
    s_splay_tree_t *splay_node;

    assert_exit(splay_tree_structure_legal_ip(tree));

    queue = array_queue_create();
    array_queue_enter(queue, tree);

    while (!array_queue_empty_p(queue)) {
        splay_node = array_queue_leave(queue);

        if (splay_node->left != NULL) {
            array_queue_enter(queue, splay_node->left);
        }
        if (splay_node->right != NULL) {
            array_queue_enter(queue, splay_node->right);
        }

        doubly_linked_list_destroy(&splay_node->list);
        memory_cache_free(splay_node);
    }

    array_queue_destroy(&queue);
}

示例#3

文件： leftist_heap.c 项目： Incarnation-p-lee/libds

static inline void
leftist_heap_node_destroy(s_leftist_heap_t *heap)
{
    assert_exit(leftist_heap_legal_ip(heap));

    memory_cache_free(heap);
}

示例#4

文件： heap_sort.c 项目： Incarnation-p-lee/libds

static inline void
heap_sort_percolate_down(void *base, uint32 size, uint32 csize, uint32 index,
    sint32 (*compare)(const void *, const void *))
{
    uint32 i;
    void *tmp;
    uint32 child;

    assert_exit(sort_parameters_legal_p(base, size, csize, compare));
    assert_exit(index < size);

    tmp = memory_cache_allocate(csize);
    sort_cell_copy(tmp, base + index * csize, csize);

    i = index;
    while (HEAP_LEFT(i) < size) {
        child = HEAP_LEFT(i);
        if (child != size - 1
            && compare(base + child * csize, base + (child + 1) * csize) < 0) {
            child++;
        }

        if (compare(tmp, base + child * csize) < 0) {
            sort_cell_copy(base + i * csize, base + child * csize, csize);
        } else {
            break;
        }
        i = child;
    }

    sort_cell_copy(base + i * csize, tmp, csize);
    memory_cache_free(tmp);
}

示例#5

文件： stacked_queue.c 项目： Incarnation-p-lee/libds

void
stacked_queue_destroy(s_stacked_queue_t **queue)
{
    if (!NULL_PTR_P(queue) && stacked_queue_structure_legal_p(*queue)) {
        array_stack_destroy(&(*queue)->enter);
        array_stack_destroy(&(*queue)->leave);
        memory_cache_free(*queue);

        *queue = NULL;
    }
}

示例#6

文件： mutex.c 项目： Incarnation-p-lee/libds

void
mutex_destroy(s_mutex_t **mutex)
{
    if (NULL_PTR_P(mutex) || MUTEX_ILLEGAL_P(*mutex)) {
        return;
    } else {
        semaphore_destroy_i(MUTEX_SEMAPHORE(*mutex));
        memory_cache_free(*mutex);

        *mutex = NULL;
    }
}