re PR fortran/63861 (OpenACC coarray ICE (also with OpenMP?))

[official-gcc.git] / libcilkrts / runtime / record-replay.cpp

/* record-replay.cpp                  -*-C++-*-
 *
 *************************************************************************
 *
 *  @copyright
 *  Copyright (C) 2012-2013, Intel Corporation
 *  All rights reserved.
 *  
 *  @copyright
 *  Redistribution and use in source and binary forms, with or without
 *  modification, are permitted provided that the following conditions
 *  are met:
 *  
 *    * Redistributions of source code must retain the above copyright
 *      notice, this list of conditions and the following disclaimer.
 *    * Redistributions in binary form must reproduce the above copyright
 *      notice, this list of conditions and the following disclaimer in
 *      the documentation and/or other materials provided with the
 *      distribution.
 *    * Neither the name of Intel Corporation nor the names of its
 *      contributors may be used to endorse or promote products derived
 *      from this software without specific prior written permission.
 *  
 *  @copyright
 *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 *  HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
 *  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
 *  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
 *  OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
 *  AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 *  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY
 *  WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 *  POSSIBILITY OF SUCH DAMAGE.
 *
 **************************************************************************/

/*
 * Implementation of the record/replay functionality for Cilk Plus
 */

#include <cstring>
#include <vector>
#include <stdlib.h>

// clang is really strict about printf formats, so use the annoying integer
// printf macros.  Unfortunately they're not avaiable on Windows
#ifdef _WIN32
#define PRIu64 "llu"
#else
#define __STDC_FORMAT_MACROS 1
#include <inttypes.h>
#endif

#include "record-replay.h"
#include "bug.h"
#include "internal/abi.h"
#include "local_state.h"
#include "full_frame.h"
#include "global_state.h"
#include "cilk_malloc.h"
#include "os.h"  // for cilkos_error()

#if RECORD_ON_REPLAY
#pragma message ("*** Record on Replay is enabled!")
#endif

// Defined to write sequence number to the logs.  Note that you cannot
// diff logs with sequence numbers because the numbers may increment in
// different orders.
//#define INCLUDE_SEQUENCE_NUMBER 1

const int PED_VERSION = 1;      // Log recording version

// Log types
enum ped_type_t
{
    ped_type_unknown,
    ped_type_steal,
    ped_type_sync,
    ped_type_orphaned,
    ped_type_last               // Flags end of the list
};

// Log type strings
#define PED_TYPE_STR_STEAL "Steal"
#define PED_TYPE_STR_SYNC "Sync"
#define PED_TYPE_STR_WORKERS "Workers"
#define PED_TYPE_STR_ORPHANED "Orphaned"

#define PED_TYPE_SIZE 16        // Buffer size for the type of pedigree.  Must
                                // hold largest pedigree record type string.
#define PEDIGREE_BUFF_SIZE 512  // Buffer size for the string representation
                                // of a pedigree.

/**
 * Data we store for a replay log entry
 */
typedef struct replay_entry_t
{
    uint64_t *m_reverse_pedigree;   /**< Reverse pedigree for replay log entry */
    ped_type_t m_type;              /**< Type of replay log entry */
    int16_t m_pedigree_len;         /**< Number of terms in reverse pedigree */
    int16_t m_value;                /**< Victim for STEALs, 0 if matching steal found for ORPHANs */

   /**
    * Load data read from the log into the entry
    */
    bool load(const char *type, const char *pedigee_str, int32_t value1, int32_t value2)
    {
        // Convert the type into an enum
        if (0 == strcmp(type, PED_TYPE_STR_STEAL))
        {
            m_type = ped_type_steal;
            m_value = (int16_t)value1;   // Victim
        }
        else
        {
            m_value = -1;      // Victim not valid
            if (0 == strcmp(type, PED_TYPE_STR_SYNC))
                m_type = ped_type_sync;
            else if (0 == strcmp(type, PED_TYPE_STR_ORPHANED))
                m_type = ped_type_orphaned;
            else
            {
                m_type = ped_type_unknown;
                return false;
            }
        }

        // Parse the pedigree
        m_pedigree_len = 0;

        const char *p = pedigee_str;
        char *end;

        uint64_t temp_pedigree[PEDIGREE_BUFF_SIZE/2];

        while(1)
        {
            temp_pedigree[m_pedigree_len++] = (uint64_t)strtol(p, &end, 10);
            if ('\0' == *end)
                break;
            p = end + 1;
        }

        // Allocate memory to hold the pedigree.
        // Copy the pedigree in reverse order since that's the order we'll
        // traverse it
        m_reverse_pedigree =
            (uint64_t *)__cilkrts_malloc(sizeof(int64_t) * m_pedigree_len);
        for (int n = 0; n < m_pedigree_len; n++)
            m_reverse_pedigree[n] = temp_pedigree[(m_pedigree_len - 1) - n];

        return true;
    }

   /**
    * Match this entry against the data supplied.  This includes walking the
    * pedigree from the specified node.
    */
    bool match (ped_type_t type, const __cilkrts_pedigree *node, int victim = -1)
    {
        int i = 0;

        // If the type isn't what they're seeking, we don't have a match
        if (type != m_type)
            return false;

        // If we're looking for a STEAL, then the victim must match
        if ((type == ped_type_steal) && (victim != m_value))
            return false;

        // Compare the current pedigree against what was recorded
        while ((NULL != node) && (i < m_pedigree_len))
        {
            // If we've got a pedigree rank difference, then we don't have
            // a match
            if (node->rank != m_reverse_pedigree[i])
                return false;
            node = node->parent;
            i++;
        }

        // Make sure we exhausted both the pedigree chain and the recorded
        // pedigree
        return ((NULL == node) && (i == m_pedigree_len));
    }

   /**
    * Advance to the next entry, skipping any ORPHANED records we didn't see
    * a matching STEAL for
    */
    replay_entry_t *next_entry()
    {
        replay_entry_t *entry = this;

        // You can't go beyond the end
        if (ped_type_last == entry->m_type)
            return entry;

        // Advance to the next entry
        entry++;

        // Skip any ORPHANED records that don't have a matching steal. We
        // initialized the value field to -1 for ORPHANED.  After loading all
        // the log data, we iterated through all the STEAL records setting the
        // matching ORPHANED record's value field to 0. So if an ORPHANED
        // record's value field is still -1, it doesn't have a matching STEAL
        // record, and I don't know why we chose not to return from the
        // spawned function.
        while ((ped_type_orphaned == entry->m_type) && (-1 == entry->m_value))
        {
            entry++;
        }

        return entry;
    }

   /**
    * Release any allocated resources
    */
    void unload()
    {
        __cilkrts_free(m_reverse_pedigree);
        m_reverse_pedigree = NULL;
    }

} replay_entry_t;

__CILKRTS_BEGIN_EXTERN_C

/**
 * Walk the pedigree and generate a string representation with underscores
 * between terms.  Currently does a recursive walk to generate a forward
 * pedigree.
 *
 * @param p The buffer that is to be filled.  Assumed to be PEDIGREE_BUFF_SIZE
 * characters long
 * @param pnode The initial pedigree term to be written.
 *
 * @return A pointer into the pedigree string buffer after a term has been
 * written.
 */
static
char * walk_pedigree_nodes(char *p, const __cilkrts_pedigree *pnode)
{
    CILK_ASSERT(pnode);
    if (pnode->parent)
    {
        p = walk_pedigree_nodes(p, pnode->parent);
        p += sprintf(p, "_");
    }

    return p + sprintf(p, "%" PRIu64, pnode->rank);
}

/**
 * Write a record to a replay log file.
 *
 * @param w The worker we're writing the pedigree for.
 * @param type The type of the pedigree record, as a string
 * @param initial_node The initial pedigree node to be written, or NULL if
 * there is no pedigree for this record type.
 * @param i1 First integer value to be written to the record.
 * @param i2 Second integer value to be written to the record. Only applies
 * to STEAL records. Defaults to -1 (unused).  The second value is always
 * written to make parsing easier.
 */
static
void write_to_replay_log (__cilkrts_worker *w, const char *type,
                          const __cilkrts_pedigree *initial_node,
                          int i1 = -1, int i2 = -1)
{
    char pedigree[PEDIGREE_BUFF_SIZE];

    // If we don't have an initial pedigree node, just use "0" to fill the slot
    if (NULL == initial_node)
        strcpy(pedigree, "0");
    else
        walk_pedigree_nodes(pedigree, initial_node);

#ifndef INCLUDE_SEQUENCE_NUMBER
    // Simply write the record
    fprintf(w->l->record_replay_fptr, "%s %s %d %d\n",
            type, pedigree, i1, i2);
#else
    // Write the record with a sequence number.  The sequence number should
    // always be the last term, and ignored on read

    static long volatile seq_num = 0;
    long write_num;

    // Atomic increment functions are compiler/OS-specific
#ifdef _WIN32
    write_num = _InterlockedIncrement(&seq_num);
#else /* GCC */
    write_num = __sync_add_and_fetch(&seq_num, 1);
#endif // _WIN32

    fprintf(w->l->record_replay_fptr, "%s %s %d %d %ld\n",
            type, pedigree, i1, i2, write_num);
#endif // INCLUDE_SEQUENCE_NUMBER

    fflush(w->l->record_replay_fptr);
}

/**
 * Record data for a successful steal.
 *
 * The pedigree for a STEAL record is the pedigree of the stolen frame.
 *
 * @note It's assumed that replay_record_steal() has already checked that we're
 * recording a log and that the record/replay functionality has not been
 * compiled out.
 *
 * @param w The worker stealing a frame.
 * @param victim_id The ID of the worker which had it's frame stolen.
 */
void replay_record_steal_internal(__cilkrts_worker *w, int32_t victim_id)
{
    // Follow the pedigree chain using worker's stack frame
    CILK_ASSERT(w->l->next_frame_ff);
    CILK_ASSERT(w->l->next_frame_ff->call_stack);

    // Record steal: STEAL pedigree victim_id thief_id
    write_to_replay_log (w, PED_TYPE_STR_STEAL,
                         &(w->l->next_frame_ff->call_stack->parent_pedigree),
                         victim_id);
}

/**
 * Record data for the worker that continues from a sync
 *
 * The pedigree for a SYNC record is the pedigree at the sync.
 *
 * @note It's assumed that replay_record_sync() has already checked that we're
 * recording a log and that the record/replay functionality has not been
 * compiled out.
 *
 * @param w The worker continuing from a sync.
 */
void replay_record_sync_internal(__cilkrts_worker *w)
{
    // Record sync: SYNC pedigree last_worker_id
    write_to_replay_log (w, PED_TYPE_STR_SYNC, &w->pedigree);
}

/**
 * Record the pedigree of an attempt to return to a stolen parent
 *
 * The pedigree for an ORPHANED record is the pedigree of our parent
 *
 * @note It's assumed that replay_record_orphaned() has already checked that
 * we're recording a log and that the record/replay functionality has not
 * been compiled out.
 *
 * @param w The worker continuing noting that it has been orphaned.
 */
void replay_record_orphaned_internal(__cilkrts_worker *w)
{
    // Record steal: ORPHANED pedigree self
    write_to_replay_log (w, PED_TYPE_STR_ORPHANED, w->pedigree.parent);
}

/**
 * Attempt to match a SYNC record.  We have a match when this worker was
 * recorded returning from the current call to __cilkrts_sync() with the
 * same pedigree and this was the worker that continued from the sync, since
 * it was the last to sync.
 *
 * If we find a match, the caller is expected to stall it is the last worker
 * to reach a sync so it will be the worker to continue from the sync.
 *
 * @note It's assumed that replay_match_sync_pedigree() has already returned
 * if we're not replaying a log, or if record/replay functionality has
 * been compiled out.
 *
 * @param w The worker we're checking to see if we've got a match
 */
int replay_match_sync_pedigree_internal(__cilkrts_worker *w)
{
    // Return true if we have a match
    if (w->l->replay_list_entry->match(ped_type_sync, &w->pedigree))
        return 1;
    else
        return 0;
}

/**
 * Advance to the next log entry from a SYNC record.  Consume the current
 * SYNC record on this worker and advance to the next one.
 *
 * @note It's assumed that replay_advance_from_sync() has already returned if
 * we're not replaying a log, or if record/replay functionality has been
 * compiled out.
 *
 * @param w The worker whose replay log we're advancing.
 */
void replay_advance_from_sync_internal (__cilkrts_worker *w)
{
    // The current replay entry must be a SYNC
    CILK_ASSERT(ped_type_sync == w->l->replay_list_entry->m_type);

    // Advance to the next entry
    w->l->replay_list_entry = w->l->replay_list_entry->next_entry();
}

/**
 * Called from random_steal() to override the ID of the randomly chosen victim
 * worker which this worker will attempt to steal from. Returns the worker id
 * of the next victim this worker was recorded stealing from, or -1 if the
 * next record in the log is not a STEAL.
 *
 * @note This call does NOT attempt to match the pedigree.  That will be done
 * by replay_match_victim_pedigree() after random_steal() has locked the victim
 * worker.
 *
 * @param w The __cilkrts_worker we're executing on.  The worker's replay log
 * is checked for a STEAL record.  If we've got one, the stolen worker ID is
 * returned.
 *
 * @return -1 if the next record is not a STEAL
 * @return recorded stolen worker ID if we've got a matching STEAL record
 */
int replay_get_next_recorded_victim_internal(__cilkrts_worker *w)
{
    // If the next record isn't a STEAL, abort the attempt to steal work
    if (ped_type_steal != w->l->replay_list_entry->m_type)
        return -1;

    // Return the victim's worker ID from the STEAL record.  We'll check
    // the pedigree after random_steal has locked the victim worker.
    return w->l->replay_list_entry->m_value;
}

/**
 * Called from random_steal() to determine if we have a STEAL record that
 * matches the pedigree at the head of the victim worker.  If we do have a
 * match, the STEAL record is consumed.
 *
 * @note It's assumed that replay_match_victim_pedigree() has already returned if
 * we're not replaying a log, or if record/replay functionality has been
 * compiled out.
 *
 * @return 1 if we have a match
 * @return 0 if the current replay record isn't a STEAL record, or the victim
 * isn't correct, or the pedigree doesn't match.
 */
int replay_match_victim_pedigree_internal(__cilkrts_worker *w, __cilkrts_worker *victim)
{
    // If we don't have a match, return 0
    if (! w->l->replay_list_entry->match(ped_type_steal,
                                             &((*victim->head)->parent_pedigree),
                                             victim->self))
        return 0;

    // Consume this entry
    w->l->replay_list_entry = w->l->replay_list_entry->next_entry();

    // Return success
    return 1;
}

/**
 * If the frame we're about to return to was recorded as being stolen,
 * stall until it is.
 *
 * @note It's assumed that replay_wait_for_steal_if_parent_was_stolen() has
 * already returned if we're not replaying a log, or if record/replay
 * functionality has been compiled out.
 *
 * @param w The worker we're executing on.
 */
void replay_wait_for_steal_if_parent_was_stolen_internal(__cilkrts_worker *w)
{
    // If our parent wasn't recorded orphanen, return now
    if (! w->l->replay_list_entry->match (ped_type_orphaned,
                                              w->pedigree.parent))
        return;

    // Stall until our parent is stolen.  Note that we're comparing head
    // and tail, not head and exc.  The steal is not completed until tail
    // is modified.
    while (!((w->tail - 1) < w->head))
        __cilkrts_sleep();

    // Consume the entry
    w->l->replay_list_entry = w->l->replay_list_entry->next_entry();
}

/**
 * Allocate memory for the list of logged events.
 *
 * This function will read through the file and count the number of records
 * so it can estimate how big a buffer to allocate for the array or replay
 * entries.  It will then rewind the file to the beginning so it can be
 * loaded into memory.
 *
 * @param w The worker we're loading the file for.
 * @param f The file of replay data we're scanning.
 */
static
void allocate_replay_list(__cilkrts_worker *w, FILE *f)
{
    // Count the number of entries - yeah, it's a hack, but it lets me
    // allocate the space all at once instead of in chunks
    char buf[1024];
    int entries = 1;    // Include "LAST" node

    while (! feof(f))
    {
        if (fgets(buf, 1024, f))
        {
            // Skip the Workers record - should only be in file for Worker 0
            if (0 != strncmp(PED_TYPE_STR_WORKERS, buf, sizeof(PED_TYPE_STR_WORKERS)-1))
                entries++;
        }
    }

    w->l->replay_list_root =
        (replay_entry_t *)__cilkrts_malloc(entries * sizeof(replay_entry_t));
    w->l->replay_list_root[entries - 1].m_type = ped_type_last;

    // Reset the file to the beginning
    rewind(f);
}

/**
 * Load the replay log for a worker into memory.
 *
 * @param w The worker we're loading the replay for.
 */
static
void load_recorded_log(__cilkrts_worker *w)
{
    char ped_type[PED_TYPE_SIZE];
    char ped_str[PEDIGREE_BUFF_SIZE];
    int32_t i1 = -1, i2 = -1;
    int fret;
    char local_replay_file_name[512];
    FILE *f;

    // Open the log for reading
    sprintf(local_replay_file_name, "%s%d.cilklog", w->g->record_replay_file_name,  w->self);
    f = fopen(local_replay_file_name, "r");

    // Make sure we found a log!
    CILK_ASSERT (NULL != f);

    // Initialize the replay_list
    allocate_replay_list(w, f);
    replay_entry_t *entry = w->l->replay_list_root;

    // Read the data out and add it to our tables
    while (! feof(f))
    {
#ifndef INCLUDE_SEQUENCE_NUMBER
        fret = fscanf(f, "%s %s %d %d\n", ped_type, ped_str, &i1, &i2);
        if(EOF == fret)
            break;

        // We must have read 4 fields
        CILK_ASSERT(4 == fret);
#else
        int32_t write_num;
        fret = fscanf(f, "%s %s %d %d %d\n", ped_type, ped_str,
                      &i1, &i2, &write_num);
        if(EOF == fret)
            break;

        // We must have read 5 fields
        CILK_ASSERT(5 == fret);
#endif // INCLUDE_SEQUENCE_NUMBER

        // Load the data into the entry
        if (0 == strcmp(ped_type, PED_TYPE_STR_WORKERS))
        {
            // Verify we're replaying with the same number of workers we recorded with
            if (i1 != w->g->P)
            {
                // Fatal error - does not return
                cilkos_error("Cannot continue replay: number of workers(%d) doesn't match "
                             "that from the recording(%d).\n", w->g->P, i1);
            }

            // Verify that we understand this version of the pedigree file
            if (PED_VERSION != i2)
            {
                // Fatal error - does not return
                cilkos_error("Pedigree file version %d doesn't match current "
                             "version %d - cannot continue.\n",
                             i2, PED_VERSION);
            }
        }
        else
        {
            entry->load(ped_type, ped_str, i1, i2);
            entry++;
        }
    }

    // Make sure we've filled the allocated memory.  We initialized the last
    // entry in 
    CILK_ASSERT(ped_type_last == entry->m_type);
    w->l->replay_list_entry = w->l->replay_list_root;

    // Close the log and return
    fclose(f);
}

/**
 * Scan a recorded log to match STEALs againsted ORPHANED records.
 *
 * @param g Cilk Runtime global state.  Passed to access the worker array so
 * we can scan a worker's ORPHANED entries for one that matches a STEAL entry.
 * @param entry The root of a replay_list for a worker.
 */
static
void scan_for_matching_steals(global_state_t *g, replay_entry_t *entry)
{
    // Iterate over all of the entries
    while (ped_type_last != entry->m_type)
    {
        // Look for STEALs.  That will tell us which worker the frame was
        // stolen from
        if (ped_type_steal == entry->m_type)
        {
            bool found = false;

            // Validate the worker ID and make sure we've got a list
            CILK_ASSERT((entry->m_value >= 0) && (entry->m_value < g->total_workers));
            replay_entry_t *victim_entry = g->workers[entry->m_value]->l->replay_list_root;
            CILK_ASSERT(NULL != victim_entry);

            // Scan the victim's list for the matching ORPHANED record
            while ((ped_type_last != victim_entry->m_type) && ! found)
            {
                if (ped_type_orphaned == victim_entry->m_type)
                {
                    if (entry->m_pedigree_len == victim_entry->m_pedigree_len)
                    {
                        if (0 == memcmp(entry->m_reverse_pedigree,
                                        victim_entry->m_reverse_pedigree,
                                        entry->m_pedigree_len * sizeof(int64_t)))
                        {
                            // Note that this ORPHANED record has a matching steal
                            victim_entry->m_value = 0;
                            found = true;
                        }
                    }
                }
                victim_entry++;
            }
        }
        entry++;
    }
}


/*
 * Initialize per-worker data for record or replay - See record-replay.h
 * for full routine header.
 */
void replay_init_workers(global_state_t *g)
{
    int i;
    char worker_file_name[512];

    // If we're not recording or replaying a log, we're done.  All of the
    // fields in the global_state_t or local_state_t are already initialized
    // to default values.
    if (RECORD_REPLAY_NONE == g->record_or_replay)
        return;

    // If we're replaying a log, read each worker's log and construct the
    // in-memory log
    if (REPLAY_LOG == g->record_or_replay)
    {
        // Read all of the data
        for (i = 0; i < g->total_workers; ++i)
        {
            // This function will also initialize and fill the worker's 
            // replay list
            load_recorded_log(g->workers[i]);
        }

        // Scan for orphans with no matching steal.  Mark them so they'll be
        // skipped as we advance through the log.
        for (i = 0; i < g->total_workers; ++i)
        {
            scan_for_matching_steals(g, g->workers[i]->l->replay_list_root);
        }

        // If we're recording the logs while replaying, create the log files.
        // This will only be used for debugging.  Create the logs in the
        // current directory.  It should be as good a place as any...
#if RECORD_ON_REPLAY
        for(i = 0; i < g->total_workers; ++i)
        {
            __cilkrts_worker *w = g->workers[i];
            sprintf(worker_file_name, "replay_log_%d.cilklog",  w->self);
            w->l->record_replay_fptr = fopen(worker_file_name, "w+");
            CILK_ASSERT(NULL != w->l->record_replay_fptr);
        }

        // Record the number of workers, file version in Worker 0's file
        write_to_replay_log (g->workers[0], PED_TYPE_STR_WORKERS, NULL, g->P, PED_VERSION);
#endif // RECORD_ON_REPLAY
    }

    // If we're recording, create the log files
    if (RECORD_LOG == g->record_or_replay)
    {
        for(i = 0; i < g->total_workers; ++i)
        {
            __cilkrts_worker *w = g->workers[i];
            sprintf(worker_file_name, "%s%d.cilklog",
                    g->record_replay_file_name,
                    w->self);
            w->l->record_replay_fptr = fopen(worker_file_name, "w+");
            CILK_ASSERT(NULL != w->l->record_replay_fptr);
        }

        // Record the number of workers, file version in Worker 0's file
        write_to_replay_log (g->workers[0], PED_TYPE_STR_WORKERS, NULL, g->P, PED_VERSION);
    }
}

/*
 * Do any necessary cleanup for the logs - See record-replay.h for full
 * routine header.
 */
void replay_term(global_state_t *g)
{
    // Free memory for the record/replay log file name, if we've got one
    if (g->record_replay_file_name)
        __cilkrts_free(g->record_replay_file_name);

    // Per-worker cleanup
    for(int i = 0; i < g->total_workers; ++i)
    {
        __cilkrts_worker *w = g->workers[i];

        // Close the log files, if we've opened them
        if(w->l->record_replay_fptr)
            fclose(w->l->record_replay_fptr);

        if (w->l->replay_list_root)
        {
            // We should have consumed the entire list
            CILK_ASSERT(ped_type_last == w->l->replay_list_entry->m_type);

            replay_entry_t *entry = w->l->replay_list_root;
            while (ped_type_last != entry->m_type)
            {
                // Free the pedigree memory for each entry
                entry->unload();
                entry++;
            }
            __cilkrts_free(w->l->replay_list_root);
            w->l->replay_list_root = NULL;
            w->l->replay_list_entry = NULL;
        }
    }
}

__CILKRTS_END_EXTERN_C