checkpoints.c

Go to the documentation of this file.

#include <stdlib.h>
#include <stdio.h>
#include <fcntl.h>

#include <mm/dymelor.h>
#include <core/timer.h>
#include <core/core.h>
#include <scheduler/scheduler.h>
#include <scheduler/process.h>
#include <statistics/statistics.h>

void *log_full(struct lp_struct *lp)
{

    void *ptr = NULL, *ckpt = NULL;
    int i;
    size_t size, chunk_size, bitmap_size;
    malloc_area *m_area;
    malloc_state *m_state;

    // Timers for self-tuning of the simulation platform
    timer checkpoint_timer;
    timer_start(checkpoint_timer);

    m_state = lp->mm->m_state;
    m_state->is_incremental = false;
    size = get_log_size(m_state);

    ckpt = rsalloc(size);

    if (unlikely(ckpt == NULL)) {
        rootsim_error(true, "(%d) Unable to acquire memory for checkpointing the current state (memory exhausted?)", lp->lid.to_int);
    }

    ptr = ckpt;

    // Copy malloc_state in the ckpt
    memcpy(ptr, m_state, sizeof(malloc_state));
    ptr = (void *)((char *)ptr + sizeof(malloc_state));
    ((malloc_state *) ckpt)->timestamp = lvt(lp);

    for (i = 0; i < m_state->num_areas; i++) {

        m_area = &m_state->areas[i];

        // Copy the bitmap

        bitmap_size = bitmap_required_size(m_area->num_chunks);

        // Check if there is at least one chunk used in the area
        if (unlikely(m_area->alloc_chunks == 0)) {

            m_area->dirty_chunks = 0;
            m_area->state_changed = 0;

            if (likely(m_area->use_bitmap != NULL)) {
                memset(m_area->dirty_bitmap, 0, bitmap_size);
            }

            continue;
        }
        // Copy malloc_area into the ckpt
        memcpy(ptr, m_area, sizeof(malloc_area));
        ptr = (void *)((char *)ptr + sizeof(malloc_area));

        memcpy(ptr, m_area->use_bitmap, bitmap_size);
        ptr = (void *)((char *)ptr + bitmap_size);

        chunk_size = UNTAGGED_CHUNK_SIZE(m_area);

        // Check whether the area should be completely copied (not on a per-chunk basis)
        // using a threshold-based heuristic
        if (CHECK_LOG_MODE_BIT(m_area)) {

            // If the malloc_area is almost (over a threshold) full, copy it entirely
            memcpy(ptr, m_area->area, m_area->num_chunks * chunk_size);
            ptr = (void *)((char *)ptr + m_area->num_chunks * chunk_size);

        } else {

#define copy_from_area(x) ({\
            memcpy(ptr, (void*)((char*)m_area->area + ((x) * chunk_size)), chunk_size);\
            ptr = (void*)((char*)ptr + chunk_size);})

            // Copy only the allocated chunks
            bitmap_foreach_set(m_area->use_bitmap, bitmap_size, copy_from_area);

#undef copy_from_area
        }

        // Reset Dirty Bitmap, as there is a full ckpt in the chain now
        m_area->dirty_chunks = 0;
        m_area->state_changed = 0;
        bzero(m_area->dirty_bitmap, bitmap_size);

    }           // For each malloc area

    // Sanity check
    if (unlikely((char *)ckpt + size != ptr))
        rootsim_error(true, "Actual (full) ckpt size is wrong by %d bytes!\nlid = %d ckpt = %p size = %#x (%d), ptr = %p, ckpt + size = %p\n",
                  (char *)ckpt + size - (char *)ptr, lp->lid.to_int,
                  ckpt, size, size, ptr, (char *)ckpt + size);

    m_state->total_inc_size = sizeof(malloc_state);

    statistics_post_data(lp, STAT_CKPT_TIME, (double)timer_value_micro(checkpoint_timer));
    statistics_post_data(lp, STAT_CKPT_MEM, (double)size);

    return ckpt;
}

void *log_state(struct lp_struct *lp)
{
    statistics_post_data(lp, STAT_CKPT, 1.0);
    return log_full(lp);
}

void restore_full(struct lp_struct *lp, void *ckpt)
{
    char *ptr, *target_ptr;
    int i, original_num_areas;
    size_t chunk_size, bitmap_size;
    malloc_area *m_area;
    malloc_state *m_state;

    // Timers for simulation platform self-tuning
    timer recovery_timer;
    timer_start(recovery_timer);
    ptr = ckpt;
    m_state = lp->mm->m_state;
    target_ptr = ptr + ((malloc_state *) ptr)->total_log_size;
    original_num_areas = m_state->num_areas;

    // restore the old malloc state except for the malloc areas array
    m_area = m_state->areas;
    memcpy(m_state, ptr, sizeof(malloc_state));
    m_state->areas = m_area;
    ptr += sizeof(malloc_state);

    // Scan areas and chunk to restore them
    for (i = 0; i < m_state->num_areas; i++) {

        m_area = &m_state->areas[i];

        bitmap_size = bitmap_required_size(m_area->num_chunks);

        if (ptr >= target_ptr || m_area->idx != ((malloc_area *) ptr)->idx) {

            m_area->dirty_chunks = 0;
            m_area->state_changed = 0;
            m_area->alloc_chunks = 0;
            m_area->next_chunk = 0;
            RESET_LOG_MODE_BIT(m_area);
            RESET_AREA_LOCK_BIT(m_area);

            if (likely(m_area->use_bitmap != NULL)) {
                memset(m_area->use_bitmap, 0, bitmap_size);
                memset(m_area->dirty_bitmap, 0, bitmap_size);
            }
            m_area->last_access = m_state->timestamp;

            continue;
        }
        // Restore the malloc_area
        memcpy(m_area, ptr, sizeof(malloc_area));
        ptr += sizeof(malloc_area);

        // Restore use bitmap
        memcpy(m_area->use_bitmap, ptr, bitmap_size);
        ptr += bitmap_size;

        // Reset dirty bitmap
        bzero(m_area->dirty_bitmap, bitmap_size);
        m_area->dirty_chunks = 0;
        m_area->state_changed = 0;

        chunk_size = UNTAGGED_CHUNK_SIZE(m_area);

        // Check how the area has been logged
        if (CHECK_LOG_MODE_BIT(m_area)) {
            // The area has been entirely logged
            memcpy(m_area->area, ptr, m_area->num_chunks * chunk_size);
            ptr += m_area->num_chunks * chunk_size;

        } else {
            // The area was partially logged.
            // Logged chunks are the ones associated with a used bit whose value is 1
            // Their number is in the alloc_chunks counter

#define copy_to_area(x) ({\
        memcpy((void*)((char*)m_area->area + ((x) * chunk_size)), ptr, chunk_size);\
        ptr += chunk_size;})

            bitmap_foreach_set(m_area->use_bitmap, bitmap_size, copy_to_area);

#undef copy_to_area
        }

    }

    // Check whether there are more allocated areas which are not present in the log
    if (original_num_areas > m_state->num_areas) {

        for (i = m_state->num_areas; i < original_num_areas; i++) {

            m_area = &m_state->areas[i];
            m_area->alloc_chunks = 0;
            m_area->dirty_chunks = 0;
            m_area->state_changed = 0;
            m_area->next_chunk = 0;
            m_area->last_access = m_state->timestamp;
            m_state->areas[m_area->prev].next = m_area->idx;

            RESET_LOG_MODE_BIT(m_area);
            RESET_AREA_LOCK_BIT(m_area);

            if (likely(m_area->use_bitmap != NULL)) {
                bitmap_size = bitmap_required_size(m_area->num_chunks);

                memset(m_area->use_bitmap, 0, bitmap_size);
                memset(m_area->dirty_bitmap, 0, bitmap_size);
            }
        }
        m_state->num_areas = original_num_areas;
    }

    m_state->timestamp = -1;
    m_state->is_incremental = false;
    m_state->total_inc_size = sizeof(malloc_state);

    statistics_post_data(lp, STAT_RECOVERY_TIME, (double)timer_value_micro(recovery_timer));
}

void log_restore(struct lp_struct *lp, state_t *state_queue_node)
{
    statistics_post_data(lp, STAT_RECOVERY, 1.0);
    restore_full(lp, state_queue_node->log);
}

void log_delete(void *ckpt)
{
    if (likely(ckpt != NULL)) {
        rsfree(ckpt);
    }
}