Knowledge_System.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 "Knowledge_System.h"
#include "Data_Entry.h"
#include "CRC64.h"





void Knowledge_system_init( struct Knowledge_system *ks, uint64_t type, uint64_t *sensivity_keys, uint32_t sensivity_count,
                                                     void (*process)( struct MALP_blackboard *bb, struct Data_entry **de, uint32_t entry_count, void *arg ), void *arg )
{

        ks->type = type;
        ks->lock = 0;
        
        ks->sensivity_count = sensivity_count;

        if( sensivity_count == 0 )
        {
                printf("Cannot create a KS with sensitity 0 ! \n");
                abort();
        }

        ks->sensivity_keys = malloc( ks->sensivity_count * sizeof( uint64_t ) );

        if( !ks->sensivity_keys )
        {
                perror( "malloc" );
                abort();
        }
        
        memcpy( ks->sensivity_keys, sensivity_keys, ks->sensivity_count * sizeof( uint64_t ) );

        ks->sensivity_array = malloc( ks->sensivity_count * sizeof( uint64_t ) );

        if( !ks->sensivity_array )
        {
                perror( "malloc" );
                abort();
        }

        ks->data_entries = malloc( ks->sensivity_count * sizeof( struct Buffered_FIFO ) );

        if( !ks->data_entries )
        {
                perror( "malloc" );
                abort();
        }

        int i = 0;
        
        for( i = 0 ; i < ks->sensivity_count ; i++ )
        {
                Buffered_FIFO_init( &ks->data_entries[i], 10, sizeof(struct Data_entry *) );
                ks->sensivity_array[i] = 0;
        }

        ks->process = process;
    ks->arg = arg;
        ks->freed = 0;
}


void Knowledge_system_release( struct Knowledge_system *ks )
{
        ks->type = 0;
        ks->lock = 1;
        
        int i = 0;
        for( i = 0 ; i < ks->sensivity_count ; i++ )
                Buffered_FIFO_release( &ks->data_entries[i], NULL );

        free( ks->data_entries  );
        ks->data_entries = NULL;
        
        ks->sensivity_count = 0;

        free( ks->sensivity_keys );
        ks->sensivity_keys = NULL;

        free( ks->sensivity_array );
        ks->sensivity_array = NULL;

        ks->process = NULL;
    ks->arg = NULL;
        ks->freed = 1;

}

void Knowledge_system_set_process( struct Knowledge_system *ks, void (*process)( struct MALP_blackboard *bb, struct Data_entry **de, uint32_t entry_count, void *arg ), void *arg )
{

        MALP_Spinlock_lock( &ks->lock );
        {
                ks->process = process;
        ks->arg = arg;
        }
        MALP_Spinlock_unlock( &ks->lock );
}


void Knowledge_system_set_serial( struct Knowledge_system *ks, int is_serial )
{

        MALP_Spinlock_lock( &ks->lock );
        {
                ks->is_serial = is_serial;
        }
        MALP_Spinlock_unlock( &ks->lock );
}



int Knowledge_system_has_unsatisfied_sensivities( struct Knowledge_system *ks )
{
        /* Check if all the requirements are satisfied to submit a job */
        int i = 0;
        for( i = 0 ; i < ks->sensivity_count; i++ )
        {
                if( ks->sensivity_array[i] == 0 )
                {
                        return 1;
                }
        }

        return 0;
}

struct Knowledge_system_job Knowledge_system_submit_data_entry( struct Knowledge_system *ks, struct Data_entry *de )
{
        struct Knowledge_system_job ret;
        /* Create an empty job */
        memset( &ret, 0, sizeof( struct Knowledge_system_job ) );

        MALP_Spinlock_lock( &ks->lock );
        {
                int local_id = -1;
                int i = 0;
                /* Find the right id for current key */
                for( i = 0 ; i < ks->sensivity_count ; i++ )
                {
                        if( ( de->key == ks->sensivity_keys[i] )
                        && (  ks->sensivity_array[i] == 0 ) ) /* We allow multiple sensivities of the same type */
                        {
                                local_id = i;
                                break;
                        }
                }
                
                /* If no local ID search sensivities again without multiple sensivites of the same type */
                if( local_id < 0 )
                {
                        for( i = 0 ; i < ks->sensivity_count ; i++ )
                        {
                                if( de->key == ks->sensivity_keys[i] )
                                {
                                        local_id = i;
                                        break;
                                }
                        }
                }

                /* This data entry is acceptable */
                if( 0 <= local_id )
                {

                        /* Store the Data Entry reference */
                        Buffered_FIFO_push( &ks->data_entries[local_id], (void *)&de );
                        /* Increment sensivity array */
                        ks->sensivity_array[local_id]++;

                        /* All sensivities ready to process and we have a handler */

                        if( !Knowledge_system_has_unsatisfied_sensivities( ks ) )
                        {
                                ret = Knowledge_system_job_new( ks );
                        }
                }

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


struct Knowledge_system_job Knowledge_system_job_new( struct Knowledge_system *ks )
{
        struct Knowledge_system_job ret;

    ret.ks_type = ks->type;
        ret.process = ks->process;
    ret.arg = ks->arg;
        ret.entries_count = ks->sensivity_count;

        /* See if this job is serial */
        ret.is_serial = ks->is_serial;

        if( ks->sensivity_count )
        {
                ret.entries = malloc( ks->sensivity_count * sizeof( struct Data_entry * ) );
                if( !ret.entries )
                {
                        perror( "malloc" );
                        abort();
                }

                /* Fill the entry list */
                int i = 0;
                for( i = 0 ; i < ks->sensivity_count ; i++ )
                {
                        struct Data_entry *tmp = NULL;
                        if( !Buffered_FIFO_pop( &ks->data_entries[i], (void *)&tmp ) )
                        {
                                /* We failled to request an element => sensivity list was not FULL */
                                abort();
                        }
                        else
                        {
                                ks->sensivity_array[i]--;
                        }
                        ret.entries[i] = tmp;
                }
        }
        else
        {
                ret.entries = NULL;
        }

        return ret;
}


void Knowledge_system_job_release( struct Knowledge_system_job *ksj )
{
        if( !ksj )
                return;

        free( ksj->entries );
        memset( ksj, 0, sizeof( struct Knowledge_system_job ) );
}