Subversion Repositories an-fpga-implementation-of-low-latency-noc-based-mpsoc

/*

 * Copyright (c) 2010-2011 The University of Texas at Austin

 * All rights reserved.

 *

 * 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 the copyright holders nor the names of its

 * contributors may be used to endorse or promote products derived from

 * this software without specific prior written permission.

 *

 * 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

 * OWNER 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.

 */

#include "netrace.h"

char*                           nt_input_popencmd;

FILE*                           nt_input_tracefile;

char*                           nt_input_buffer;

nt_header_t*            nt_input_trheader;

int                                     nt_dependencies_off;

int                                     nt_self_throttling;

int                                     nt_primed_self_throttle;

int                                     nt_done_reading;

unsigned long long int nt_latest_active_packet_cycle;

nt_dep_ref_node_t** nt_dependency_array;

unsigned long long int nt_num_active_packets;

const char* nt_packet_types[] = { "InvalidCmd", "ReadReq", "ReadResp",

                                "ReadRespWithInvalidate", "WriteReq", "WriteResp",

                                "Writeback", "InvalidCmd", "InvalidCmd", "InvalidCmd",

                                "InvalidCmd", "InvalidCmd", "InvalidCmd", "UpgradeReq",

                                "UpgradeResp", "ReadExReq", "ReadExResp", "InvalidCmd",

                                "InvalidCmd", "InvalidCmd", "InvalidCmd", "InvalidCmd",

                                "InvalidCmd", "InvalidCmd", "InvalidCmd", "BadAddressError",

                                "InvalidCmd", "InvalidateReq", "InvalidateResp",

                                "DowngradeReq", "DowngradeResp" };

int nt_packet_sizes[] = { /*InvalidCmd*/ -1, /*ReadReq*/ 8, /*ReadResp*/ 72,

                                /*ReadRespWithInvalidate*/ 72, /*WriteReq*/ 72, /*WriteResp*/ 8,

                                /*Writeback*/ 72, /*InvalidCmd*/ -1, /*InvalidCmd*/ -1, /*InvalidCmd*/ -1,

                                /*InvalidCmd*/ -1, /*InvalidCmd*/ -1, /*InvalidCmd*/ -1, /*UpgradeReq*/ 8,

                                /*UpgradeResp*/ 8, /*ReadExReq*/ 8, /*ReadExResp*/ 72, /*InvalidCmd*/ -1,

                                /*InvalidCmd*/ -1, /*InvalidCmd*/ -1, /*InvalidCmd*/ -1, /*InvalidCmd*/ -1,

                                /*InvalidCmd*/ -1, /*InvalidCmd*/ -1, /*InvalidCmd*/ -1, /*BadAddressError*/ 8,

                                /*InvalidCmd*/ -1, /*InvalidateReq*/ 8, /*InvalidateResp*/ 8,

                                /*DowngradeReq*/ 8, /*DowngradeResp*/ 72 };

const char* nt_node_types[] = { "L1 Data Cache", "L1 Instruction Cache",

                                "L2 Cache", "Memory Controller", "Invalid Node Type" };

nt_packet_list_t*       nt_cleared_packets_list;

nt_packet_list_t*       nt_cleared_packets_list_tail;

int nt_track_cleared_packets_list;

void nt_open_trfile(  char* trfilename ) {

        nt_close_trfile();

        int i;

        int length = 20;

        for( i = 0; trfilename[i] != 0; i++, length++ );

        nt_input_popencmd = (char*) nt_checked_malloc( length * sizeof(char) );

        sprintf( nt_input_popencmd, "bzip2 -dc %s", trfilename );

        nt_input_tracefile = popen( nt_input_popencmd, "r" );

        if( nt_input_tracefile == NULL ) {

                nt_error( "failed to open pipe to trace file" );

        }

        nt_input_trheader = nt_read_trheader();

        if( nt_dependency_array == NULL ) {

                nt_dependency_array = (nt_dep_ref_node_t**) nt_checked_malloc( sizeof(nt_dep_ref_node_t*) * NT_DEPENDENCY_ARRAY_SIZE );

                memset( nt_dependency_array, 0, sizeof(nt_dep_ref_node_t*) * NT_DEPENDENCY_ARRAY_SIZE );

                nt_num_active_packets = 0;

        } else {

                nt_error( "dependency array not NULL on file open" );

        }

}

nt_header_t* nt_read_trheader() {

        #pragma pack(push,1)

        struct nt_header_pack {

                unsigned int nt_magic;

                float version;

                char benchmark_name[NT_BMARK_NAME_LENGTH];

                unsigned char num_nodes;

                unsigned char pad;

                unsigned long long int num_cycles;

                unsigned long long int num_packets;

                unsigned int notes_length;  // Includes null-terminating char

                unsigned int num_regions;

                char padding[8];

        };

        #pragma pack(pop)

        int err = 0;

        char strerr[180];

        // Read Header

        struct nt_header_pack* in_header = (struct nt_header_pack*)nt_checked_malloc( sizeof(struct nt_header_pack) );

        fseek( nt_input_tracefile, 0, SEEK_SET );

        if( (err = fread( in_header, sizeof(struct nt_header_pack), 1, nt_input_tracefile )) < 0 ) {

                sprintf( strerr, "failed to read trace file header: err = %d", err );

                nt_error( strerr );

        }

        // Copy data from struct to header

        nt_header_t* to_return = (nt_header_t*) nt_checked_malloc( sizeof(nt_header_t) );

        memset( to_return, 0, sizeof(nt_header_t) );

        to_return->nt_magic = in_header->nt_magic;

        to_return->version = in_header->version;

        strcpy( to_return->benchmark_name, in_header->benchmark_name );

        to_return->num_nodes = in_header->num_nodes;

        to_return->num_cycles = in_header->num_cycles;

        to_return->num_packets = in_header->num_packets;

        to_return->notes_length = in_header->notes_length;

        to_return->num_regions = in_header->num_regions;

        free( in_header );

        // Error Checking

        if( to_return->nt_magic != NT_MAGIC ) {

                if( nt_little_endian() != 1 ) {

                        nt_error( "only little endian architectures are currently supported" );

                } else {

                        nt_error( "invalid trace file: bad magic" );

                }

        }

        if( to_return->version != 1.0f ) {

                sprintf( strerr, "trace file is unsupported version: %f", to_return->version );

                nt_error( strerr );

        }

        // Read Rest of Header

        if( to_return->notes_length > 0 && to_return->notes_length < 8192 ) {

                to_return->notes = (char*) nt_checked_malloc( to_return->notes_length * sizeof(char) );

                if( (err = fread( to_return->notes, sizeof(char), to_return->notes_length, nt_input_tracefile )) < 0 ) {

                        sprintf( strerr, "failed to read trace file header notes: err = %d\n", err );

                        nt_error( strerr );

                }

        } else {

                to_return->notes = NULL;

        }

        if( to_return->num_regions > 0 ) {

                if( to_return->num_regions <= 100 ) {

                        to_return->regions = (nt_regionhead_t*) nt_checked_malloc( to_return->num_regions * sizeof(nt_regionhead_t) );

                        if( (err = fread( to_return->regions, sizeof(nt_regionhead_t), to_return->num_regions, nt_input_tracefile )) < 0 ) {

                                sprintf( strerr, "failed to read trace file header regions: error = %d\n", err );

                                nt_error( strerr );

                        }

                } else {

                        nt_error( "lots of regions... is this correct?" );

                }

        } else {

                to_return->regions = NULL;

        }

        return to_return;

}

void nt_disable_dependencies() {

        if( nt_track_cleared_packets_list ) {

                nt_error( "Cannot turn off dependencies when tracking cleared packets list" );

        }

        nt_dependencies_off = 1;

}

void nt_seek_region( nt_regionhead_t* region ) {

        int err = 0;

        char strerr[180];

        if( nt_input_tracefile != NULL ) {

                if( region != NULL ) {

                        // Clear all existing dependencies

                        nt_delete_all_dependencies();

                        // Reopen file to fast-forward to region

                        // fseek doesn't work on compressed file

                        pclose( nt_input_tracefile );

                        nt_input_tracefile = popen( nt_input_popencmd, "r" );

            unsigned long long int seek_offset = nt_get_headersize() + region->seek_offset;

            unsigned long long int read_length = 4096;

                        char* buffer = (char*) nt_checked_malloc( read_length );

                        while( seek_offset > read_length ) {

                                if( (err = fread( buffer, 1, read_length, nt_input_tracefile )) < 0 ) {

                                        sprintf( strerr, "failed to seek region: error = %d\n", err );

                                        nt_error( strerr );

                                }

                                seek_offset -= read_length;

                        }

                        if( (err = fread( buffer, 1, seek_offset, nt_input_tracefile )) < 0 ) {

                                sprintf( strerr, "failed to seek region: error = %d\n", err );

                                nt_error( strerr );

                        }

                        free( buffer );

                        if( nt_self_throttling ) {

                                // Prime the pump to read in self throttled packets

                                nt_prime_self_throttle();

                        }

                } else {

                        nt_error( "invalid region passed: NULL" );

                }

        } else {

                nt_error( "must open trace file with nt_open_trfile before seeking" );

        }

}

nt_packet_t* nt_read_packet( void ) {

        #pragma pack(push,1)

        struct nt_packet_pack {

                unsigned long long int cycle;

                unsigned int id;

                unsigned int addr;

                unsigned char type;

                unsigned char src;

                unsigned char dst;

                unsigned char node_types;

                unsigned char num_deps;

        };

        #pragma pack(pop)

        int err = 0;

        unsigned int i;

        char strerr[180];

        nt_packet_t* to_return = NULL;

        if( nt_input_tracefile != NULL ) {

                to_return = nt_packet_malloc();

                if( (err = fread( to_return, 1, sizeof(struct nt_packet_pack), nt_input_tracefile )) < 0 ) {

                        sprintf( strerr, "failed to read packet: err = %d", err );

                        nt_error( strerr );

                }

                if( err > 0 && err < (int) sizeof(struct nt_packet_pack) ) {

                        // Bad packet - end of file

                        nt_error( "unexpectedly reached end of trace file - perhaps corrupt" );

                } else if( err == 0 ) {

                        // End of file

                        free( to_return );

                        to_return = NULL;

                        return to_return;

                }

                if( !nt_dependencies_off ) {

                        // Track dependencies: add to_return to dependencies array

                        nt_dep_ref_node_t* node_ptr = nt_get_dependency_node( to_return->id );

                        if( node_ptr == NULL ) {

                                node_ptr = nt_add_dependency_node( to_return->id );

                        }

                        node_ptr->node_packet = to_return;

                }

                nt_num_active_packets++;

                nt_latest_active_packet_cycle = to_return->cycle;

                if( to_return->num_deps == 0 ) {

                        to_return->deps = NULL;

                } else {

                        to_return->deps = nt_dependency_malloc( to_return->num_deps );

                        if( (err = fread( to_return->deps, sizeof(nt_dependency_t), to_return->num_deps, nt_input_tracefile )) < 0 ) {

                                sprintf( strerr, "failed to read dependencies: err = %d", err );

                                nt_error( strerr );

                        }

                        if( !nt_dependencies_off ) {

                                // Track dependencies: add to_return downward dependencies to array

                                for( i = 0; i < to_return->num_deps; i++ ) {

                                        unsigned int dep_id = to_return->deps[i];

                                        nt_dep_ref_node_t* node_ptr = nt_get_dependency_node( dep_id );

                                        if( node_ptr == NULL ) {

                                                node_ptr = nt_add_dependency_node( dep_id );

                                        }

                                        node_ptr->ref_count++;

                                }

                        }

                }

        } else {

                nt_error( "must open trace file with nt_open_trfile before reading" );

        }

        return to_return;

}

nt_dep_ref_node_t* nt_add_dependency_node( unsigned int packet_id ) {

        if( nt_dependency_array != NULL ) {

                unsigned int index = packet_id % NT_DEPENDENCY_ARRAY_SIZE;

                nt_dep_ref_node_t* dep_ptr = nt_dependency_array[index];

                if( dep_ptr == NULL ) {

                        nt_dependency_array[index] = (nt_dep_ref_node_t*) nt_checked_malloc( sizeof(nt_dep_ref_node_t) );

                        dep_ptr = nt_dependency_array[index];

                } else {

                        for( ; dep_ptr->next_node != NULL; dep_ptr = dep_ptr->next_node );

                        dep_ptr->next_node =(nt_dep_ref_node_t*) nt_checked_malloc( sizeof(nt_dep_ref_node_t) );

                        dep_ptr = dep_ptr->next_node;

                }

                dep_ptr->node_packet = NULL;

                dep_ptr->packet_id = packet_id;

                dep_ptr->ref_count = 0;

                dep_ptr->next_node = NULL;

                return dep_ptr;

        } else {

                nt_error( "dependency array NULL on node addition" );

        }

        return NULL;

}

void nt_read_ahead( unsigned long long int current_cycle ) {

        unsigned long long int read_to_cycle = current_cycle + NT_READ_AHEAD;

        if( read_to_cycle < current_cycle ) {

                nt_error( "trying to read too far ahead... overflowed :(" );

        }

        if( read_to_cycle > nt_latest_active_packet_cycle ) {

                nt_packet_t* packet;

                int d= ((end_sim_pck_num == 0 ) || (end_sim_pck_num > nt_tr_list_pck ));

                while( nt_latest_active_packet_cycle <= read_to_cycle && !nt_done_reading && (d==1) ) {

                        packet = nt_read_packet();

                        nt_tr_list_pck++;

                        //printf("nt_tr_list_pck=%u\n",nt_tr_list_pck);

                        if( packet == NULL ) {

                                // This is the exit condition... how do we signal it to the

                                // network simulator? We shouldn't need to... It is tracking

                                // whether there are packets in flight.

                                // Just in case, we'll provide this global indicator

                                nt_done_reading = 1;

                        } else if( nt_dependencies_cleared( packet ) ) {

                                nt_add_cleared_packet_to_list( packet );

                        //} else {

                                // Ignore this packet, since the reader is already tracking it

                        }

                }

        }

}

nt_packet_t* nt_remove_dependency_node( unsigned int packet_id ) {

        if( nt_dependency_array != NULL ) {

                unsigned int index = packet_id % NT_DEPENDENCY_ARRAY_SIZE;

                nt_dep_ref_node_t* dep_ptr = nt_dependency_array[index];

                if( dep_ptr == NULL ) {

                        return NULL;

                } else {

                        nt_dep_ref_node_t* prev_ptr = NULL;

                        for( ; dep_ptr != NULL; prev_ptr = dep_ptr, dep_ptr = dep_ptr->next_node ) {

                                if( dep_ptr->packet_id == packet_id ) break;

                        }

                        if( dep_ptr == NULL ) {

                                return NULL;

                        }

                        if( prev_ptr == NULL ) {

                                nt_dependency_array[index] = dep_ptr->next_node;

                        } else {

                                prev_ptr->next_node = dep_ptr->next_node;

                        }

                        nt_packet_t* packet = dep_ptr->node_packet;

                        free( dep_ptr );

                        return packet;

                }

        } else {

                nt_error( "dependency array NULL on node remove" );

        }

        return NULL;

}

nt_dep_ref_node_t* nt_get_dependency_node( unsigned int packet_id ) {

        if( nt_dependency_array != NULL ) {

                unsigned int index = packet_id % NT_DEPENDENCY_ARRAY_SIZE;

                nt_dep_ref_node_t* dep_ptr;

                for( dep_ptr = nt_dependency_array[index]; dep_ptr != NULL; dep_ptr = dep_ptr->next_node ) {

                        if( dep_ptr->packet_id == packet_id ) break;

                }

                return dep_ptr;

        } else {

                nt_error( "dependency array not NULL on node search" );

        }

        return NULL;

}

int nt_dependencies_cleared( nt_packet_t* packet ) {

        if( nt_input_tracefile != NULL ) {

                nt_dep_ref_node_t* node_ptr = nt_get_dependency_node( packet->id );

                if( node_ptr == NULL || nt_dependencies_off ) {

                        return 1;

                } else {

                        return (node_ptr->ref_count == 0);

                }

        } else {

                nt_error( "must open trace file with nt_open_trfile before injecting" );

        }

        return 1;

}

void nt_clear_dependencies_free_packet( nt_packet_t* packet ) {

        unsigned int i;

        if( nt_input_tracefile != NULL ) {

                if( packet != NULL ) {

                        // If self-throttling, read ahead in the trace file

                        // to ensure that there are new packets ready to go

                        if( nt_self_throttling ) {

                                nt_read_ahead( packet->cycle );

                        }

                        for( i = 0; i < packet->num_deps; i++ ) {

                                unsigned int dep_id = packet->deps[i];

                                nt_dep_ref_node_t* node_ptr = nt_get_dependency_node( dep_id );

                                if( node_ptr == NULL ) {

                                        if( !nt_dependencies_off ) {

                                                // TODO: check if this is a problem with short seeks

                                                nt_print_packet( packet );

                                                nt_error( "failed to find dependency node" );

                                        }

                                } else {

                                        if( node_ptr->ref_count == 0 ) {

                                                nt_error( "invalid reference count on node while decrementing" );

                                        }

                                        node_ptr->ref_count--;

                                        if( nt_track_cleared_packets_list ) {

                                                if( node_ptr->ref_count == 0 ) {

                                                        // This test alleviates the possibility of a packet

                                                        // having ref_count zero before it has been read

                                                        // from the trace (node_packet = NULL)

                                                        if( node_ptr->node_packet ) {

                                                                nt_add_cleared_packet_to_list( node_ptr->node_packet );

                                                        }

                                                }

                                        }

                                }

                        }

                        nt_remove_dependency_node( packet->id );

                        nt_packet_free( packet );

                        nt_num_active_packets--;

                }

        } else {

                nt_error( "must open trace file with nt_open_trfile before ejecting" );

        }

}

void nt_init_cleared_packets_list() {

        if( nt_dependencies_off ) {

                nt_error( "Cannot return cleared packets list when dependencies are turned off" );

        }

        nt_track_cleared_packets_list = 1;

        nt_cleared_packets_list = NULL;

        nt_cleared_packets_list_tail = NULL;

}

void nt_init_self_throttling() {

        if( nt_dependencies_off ) {

                nt_error( "Cannot self throttle packets when dependencies are turned off" );

        }

        nt_self_throttling = 1;

        nt_primed_self_throttle = 0;

        nt_init_cleared_packets_list();

}

nt_packet_list_t* nt_get_cleared_packets_list() {

        if( !nt_primed_self_throttle ) {

                nt_prime_self_throttle();

        }

        return nt_cleared_packets_list;

}

void nt_prime_self_throttle() {

        nt_packet_t* packet = nt_read_packet();

    nt_tr_list_pck++;

        if( nt_dependencies_cleared( packet ) ) {

                nt_add_cleared_packet_to_list( packet );

        }

        nt_primed_self_throttle = 1;

        nt_read_ahead( packet->cycle );

}

void nt_add_cleared_packet_to_list( nt_packet_t* packet ) {

        nt_packet_list_t* new_node = (nt_packet_list_t*) nt_checked_malloc( sizeof(nt_packet_list_t) );

        new_node->node_packet = packet;

        new_node->next = NULL;

        if( nt_cleared_packets_list == NULL ) {

                nt_cleared_packets_list = nt_cleared_packets_list_tail = new_node;

        } else {

                nt_cleared_packets_list_tail->next = new_node;

                nt_cleared_packets_list_tail = new_node;

        }

}

void nt_empty_cleared_packets_list() {

        while( nt_cleared_packets_list != NULL ) {

                nt_packet_list_t* temp = nt_cleared_packets_list;

                nt_cleared_packets_list = nt_cleared_packets_list->next;

                free( temp );

        }

        nt_cleared_packets_list = nt_cleared_packets_list_tail = NULL;

}

void nt_close_trfile() {

        if( nt_input_tracefile != NULL ) {

                pclose( nt_input_tracefile );

                nt_input_tracefile = NULL;

                nt_free_trheader( nt_input_trheader );

                if( nt_input_popencmd != NULL ) {

                        free( nt_input_popencmd );

                }

                nt_input_popencmd = NULL;

                nt_delete_all_dependencies();

                free(nt_dependency_array);

                nt_dependency_array = NULL;

        }

}

void nt_delete_all_dependencies() {

        int i;

        for( i = 0; i < NT_DEPENDENCY_ARRAY_SIZE; i++ ) {

                while( nt_dependency_array[i] != NULL ) {

                        nt_remove_dependency_node( nt_dependency_array[i]->packet_id );

                }

        }

}

void nt_print_header( nt_header_t* header ) {

        unsigned int i;

        if( header != NULL ) {

                printf( "NT_TRACEFILE---------------------\n" );

                printf( "  Benchmark: %s\n", header->benchmark_name );

                printf( "  Magic Correct? %s\n", (header->nt_magic == NT_MAGIC) ? "TRUE" : "FALSE" );

                printf( "  Tracefile Version: v%1.1f\n", header->version );

                printf( "  Number of Program Regions: %d\n", header->num_regions );

                printf( "  Number of Simulated Nodes: %d\n", header->num_nodes );

                printf( "  Simulated Cycles: %lld\n", header->num_cycles );

                printf( "  Simulated Packets: %lld\n", header->num_packets );

                printf( "  Average injection rate: %f\n", (double)header->num_packets / (double)header->num_cycles );

                if( header->notes_length > 0 ) {

                        printf( "  Notes: %s\n", header->notes );

                }

                for( i = 0; i < header->num_regions; i++ ) {

                        printf( "    Region %d:\n", i );

                        printf( "      Seek Offset: %lld\n", header->regions[i].seek_offset );

                        printf( "      Simulated Cycles: %lld\n", header->regions[i].num_cycles );

                        printf( "      Simulated Packets: %lld\n", header->regions[i].num_packets );

                        printf( "      Average injection rate: %f\n", (double)header->regions[i].num_packets / (double)header->regions[i].num_cycles );

                        printf( "      Average injection rate per node: %f\n", (double)header->regions[i].num_packets / (double)header->regions[i].num_cycles / (double)header->num_nodes );

                }

                printf( "  Size of header (B): %u\n", nt_get_headersize() );

                printf( "NT_TRACEFILE---------------------\n" );

        } else {

                printf( "NULL header passed to nt_print_header\n" );

        }

}

void nt_print_trheader() {

        nt_print_header( nt_input_trheader );

}

nt_header_t* nt_get_trheader() {

        if( nt_input_tracefile != NULL ) {

                return nt_input_trheader;

        } else {

                nt_error( "must open trace file with nt_open_trfile before header is available" );

        }

        return NULL;

}

float nt_get_trversion() {

        if( nt_input_tracefile != NULL ) {

                return nt_input_trheader->version;

        } else {

                nt_error( "must open trace file with nt_open_trfile before version is available" );

        }

        return 0.0f;

}

nt_packet_t* nt_packet_malloc() {

        // TODO: v1.1?

        // Allocate large array (1+ pages) to reduce # system calls

        return (nt_packet_t*) nt_checked_malloc( sizeof(nt_packet_t) );

}

nt_dependency_t* nt_dependency_malloc( unsigned char num_deps ) {

        // TODO: v1.1?

        // Allocate large array (1+ pages) to reduce # system calls

        return (nt_dependency_t*) nt_checked_malloc( num_deps * sizeof(nt_dependency_t) );

}

int nt_get_src_type( nt_packet_t* packet ) {

        return (int) ( packet->node_types >> 4 );

}

int nt_get_dst_type( nt_packet_t* packet ) {

        return (int) ( 0xF & packet->node_types );

}

const char* nt_node_type_to_string( int type ) {

        if( type < NT_NUM_NODE_TYPES ) {

                return nt_node_types[type];

        } else {

                return nt_node_types[NT_NUM_NODE_TYPES];

        }

}

int nt_get_packet_size( nt_packet_t* packet ) {

        if( packet->type < NT_NUM_PACKET_TYPES ) {

                return nt_packet_sizes[packet->type];

        } else {

                return nt_packet_sizes[0];