Key_Entry.c

Go to the documentation of this file.

/* ############################ MALP License ############################## */
/* # Fri Jan 18 14:00:00 CET 2013                                         # */
/* # Copyright or (C) or Copr. Commissariat a l'Energie Atomique          # */
/* #                                                                      # */
/* # This software is governed by the CeCILL-C license under French law   # */
/* # and abiding by the rules of distribution of free software.  You can  # */
/* # use, modify and/ or redistribute the software under the terms of     # */
/* # the CeCILL-C license as circulated by CEA, CNRS and INRIA at the     # */
/* # following URL http://www.cecill.info.                                # */
/* #                                                                      # */
/* # The fact that you are presently reading this means that you have     # */
/* # had knowledge of the CeCILL-C license and that you accept its        # */
/* # terms.                                                               # */
/* #                                                                      # */
/* # Authors:                                                             # */
/* #   - BESNARD Jean-Baptiste jean-baptiste.besnard@cea.fr               # */
/* #                                                                      # */
/* ######################################################################## */
#include "Key_Entry.h"
#include "Knowledge_System.h"

#define KEY_ENTRY_CL_COLL_AVOID 5


/* Init a key entry with givent key */
void Key_entry_init( struct Key_entry *ke, uint64_t key )
{
        ke->freed = 0;
        ke->lock = 0;
        ke->key = key;
        Chained_List_init(&(ke->target_ks), KEY_ENTRY_CL_COLL_AVOID, sizeof(struct Knowledge_system *));
}

/* Clears a key entry */
void Key_entry_release( struct Key_entry *ke )
{
        ke->freed = 1;
        ke->lock = 1;
        ke->key = 0;
        Chained_List_release(&ke->target_ks);
}


struct Knowledge_system **  Key_entry_find_empty( struct Key_entry *ke )
{
        struct chained_list_view clv;
        chained_list_view_init( &clv );
        
        struct Knowledge_system ** tmp = NULL;
        int i = 0;
        
        while( ( tmp = (struct Knowledge_system **)Chained_List_get_nth_seq(&(ke->target_ks), &clv, i) ) )
        {
                if( tmp )
                {
                                if( *tmp == NULL )
                                {
                                                return tmp;
                                }       
                }
                i++;
        }

        return NULL;
}

struct Knowledge_system **  Key_entry_get_ks( struct Key_entry *ke, struct Knowledge_system *ks )
{
        struct chained_list_view clv;
        chained_list_view_init( &clv );

        struct Knowledge_system ** tmp = NULL;
        int i = 0;
        

        while( ( tmp = (struct Knowledge_system **)Chained_List_get_nth_seq(&(ke->target_ks), &clv, i) ) )
        {
                if( tmp )
                {
                                if( *tmp == ks )
                                {
                                                return tmp;
                                }       
                }
                i++;
        }

        return NULL;
}


/* Add this Ks if not already present */
void Key_entry_push_ks( struct Key_entry *ke, struct Knowledge_system *ks )
{
        MALP_Spinlock_lock(&ke->lock);
        {

                if( Key_entry_get_ks( ke, ks ) )
                {
                                /* This ks is already registered */
                                MALP_Spinlock_unlock(&ke->lock);
                                return;
                }

                struct Knowledge_system **empty_ks = NULL;
                
                if( (empty_ks =  Key_entry_find_empty( ke ) ) != NULL )
                {
                        /* Found an empty slot */
                        *empty_ks = ks;
                }
                else
                {
                        /* Creating a new slot */
                        Chained_List_push(&ke->target_ks, (void*)&ks);
                }
                
        }
        MALP_Spinlock_unlock(&ke->lock);
}

/* Remove all references to this Ks */
void Key_entry_pop_ks( struct Key_entry *ke, struct Knowledge_system *ks )
{
        MALP_Spinlock_lock(&ke->lock);
        {
                struct Knowledge_system **to_delete = NULL;
                
                if( ( to_delete = Key_entry_get_ks( ke, ks ) ) != NULL )
                {
                        *to_delete = NULL;
                }       
        }
        MALP_Spinlock_unlock(&ke->lock);
}

/* Clear all references to Ks in this entry */
void Key_entry_clear_ks( struct Key_entry *ke )
{
        MALP_Spinlock_lock(&ke->lock);
        {
                if( ke->target_ks.count != 0 )
                {
                        Chained_List_release(&ke->target_ks);
                        /* A bit hacky but the simplest way to clear all nulled entries */
                        Chained_List_init(&ke->target_ks, KEY_ENTRY_CL_COLL_AVOID, sizeof(struct Knowledge_system *));
                }
        }
        MALP_Spinlock_unlock(&ke->lock);
}

/* Get the number of Ks in this entry */
int Key_entry_get_count( struct Key_entry *ke )
{
        int ret = 0;
        MALP_Spinlock_lock(&ke->lock);
        {
                struct chained_list_view clv;
                chained_list_view_init( &clv );
                
                struct Knowledge_system ** tmp = NULL;
                int i = 0;
                
                while( ( tmp = (struct Knowledge_system **)Chained_List_get_nth_seq(&ke->target_ks, &clv, i) ) )
                {
                        if( tmp )
                        {
                                        if( *tmp )
                                        {
                                                        ret++;
                                        }       
                        }
                        i++;
                }
        }
        MALP_Spinlock_unlock(&ke->lock);

        return ret;
}

int Key_entry_has_KS_type( struct Key_entry *ke, uint64_t type )
{
        int ret = 0;
        MALP_Spinlock_lock(&ke->lock);
        {
                struct chained_list_view clv;
                chained_list_view_init( &clv );
                
                struct Knowledge_system ** tmp = NULL;
                int i = 0;
                
                while( ( tmp = (struct Knowledge_system **)Chained_List_get_nth_seq(&ke->target_ks, &clv, i) ) )
                {
                        if( tmp )
                        {
                                        if( (*tmp)->type == type )
                                        {
                                                ret = 1;
                                                break;
                                        }
                        }
                        i++;
                }

        }
        MALP_Spinlock_unlock(&ke->lock);
        return ret;
}



/* Call a handler on every Ks >>> if handler returns 1 walk is interupted  <<<*/
void Key_entry_walk( struct Key_entry *ke, int (*handler)( struct Knowledge_system *, void *), void *arg )
{
        if( !handler )
                return;
        
        MALP_Spinlock_lock(&ke->lock);
        {
                struct chained_list_view clv;
                chained_list_view_init( &clv );
                
                struct Knowledge_system ** tmp = NULL;
                int i = 0;
                
                while( ( tmp = (struct Knowledge_system **)Chained_List_get_nth_seq(&ke->target_ks, &clv, i) ) )
                {
                        if( tmp )
                        {
                                        if( (handler)( *tmp, arg ) )
                                                break;
                        }
                        i++;
                }

        }
        MALP_Spinlock_unlock(&ke->lock);
}