checkpoints.c

Go to the documentation of this file.

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

#include <mm/mm.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;

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

    lp->mm->m_state->is_incremental = false;
    size = get_log_size(lp->mm->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, lp->mm->m_state, sizeof(malloc_state));
    ptr = (void *)((char *)ptr + sizeof(malloc_state));
    ((malloc_state *) ckpt)->timestamp = lvt(lp);

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

        m_area = &lp->mm->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((void *)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);

    lp->mm->m_state->dirty_areas = 0;
    lp->mm->m_state->dirty_bitmap_size = 0;
    lp->mm->m_state->total_inc_size = 0;

    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)
{
    void *ptr;
    int i, original_num_areas, restored_areas;
    size_t chunk_size, bitmap_size;
    malloc_area *m_area, *new_area;

    // Timers for simulation platform self-tuning
    timer recovery_timer;
    timer_start(recovery_timer);
    restored_areas = 0;
    ptr = ckpt;
    original_num_areas = lp->mm->m_state->num_areas;
    new_area = lp->mm->m_state->areas;

    // Restore malloc_state
    memcpy(lp->mm->m_state, ptr, sizeof(malloc_state));
    ptr = (void *)((char *)ptr + sizeof(malloc_state));

    lp->mm->m_state->areas = new_area;

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

        m_area = &lp->mm->m_state->areas[i];

        bitmap_size = bitmap_required_size(m_area->num_chunks);

        if (restored_areas == lp->mm->m_state->busy_areas || 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 = lp->mm->m_state->timestamp;

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

        restored_areas++;

        // Restore use bitmap
        memcpy(m_area->use_bitmap, ptr, bitmap_size);
        ptr = (void *)((char *)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 = (void *)((char *)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 = (void*)((char*)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 > lp->mm->m_state->num_areas) {

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

            m_area = &lp->mm->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 = lp->mm->m_state->timestamp;
            lp->mm->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);
            }
        }
        lp->mm->m_state->num_areas = original_num_areas;
    }

    lp->mm->m_state->timestamp = -1;
    lp->mm->m_state->is_incremental = false;
    lp->mm->m_state->dirty_areas = 0;
    lp->mm->m_state->dirty_bitmap_size = 0;
    lp->mm->m_state->total_inc_size = 0;

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