MALP_Blackboard.h

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               # */
/* #                                                                      # */
/* ######################################################################## */
#ifndef MALP_BB_H
#define MALP_BB_H

#ifdef __cplusplus
extern "C" {
#endif

#include <stddef.h>
#include <stdint.h>
#include <unistd.h>

#include "Hash_Table.h"
#include "Chained_List.h"
#include "Spinlock.h"

#include "Knowledge_System.h"
#include "Data_Entry.h"
#include "Key_Entry.h"
#include "Pbb_Workers.h"

#include "MALP_Blackboard_Level.h"

#define KS_COLL_AVOID 5

struct Ks_cell
{
    struct Hash_Table_Internal ___;             
    struct Knowledge_system ks[KS_COLL_AVOID];  
};

#define KEY_COLL_AVOID 5

struct Key_cell
{
    struct Hash_Table_Internal ___;         
    struct Key_entry ke[KEY_COLL_AVOID];    
};

#define NAME_COLL_AVOID 5

struct Name_cell
{
    struct Hash_Table_Internal ___; 
    void *name[NAME_COLL_AVOID];    
};

struct MALP_blackboard
{
    struct Hash_Table ks_table;         
    struct Hash_Table key_table;        
    struct Hash_Table de_name_table;    
    struct Pbb_workers workers;         
    void (*default_handler)( struct MALP_blackboard *, uint64_t KS_id, struct Data_entry **, uint32_t, void *arg); 
    void *context;                      
    volatile uint64_t pending_datas;    
    uint32_t cpu_count;                 
    MALP_Spinlock lock;                 
};


void MALP_blackboard_init( struct MALP_blackboard *bb, uint32_t workers_count, void *context );

static inline void MALP_blackboard_set_default_KS_handler( struct MALP_blackboard *bb, void (*default_handler)( struct MALP_blackboard *, uint64_t KS_id, struct Data_entry **, uint32_t, void * ) )
{
    bb->default_handler = default_handler;
}


void MALP_blackboard_wait( struct MALP_blackboard *bb );

void MALP_blackboard_release( struct MALP_blackboard *bb );


static inline uint32_t MALP_blackboard_cpu_count(struct MALP_blackboard *bb)
{
        return bb->cpu_count;
}


int MALP_Blackboard_ks_present( struct MALP_blackboard *bb, uint64_t type );

struct Knowledge_system *  MALP_Blackboard_new_ks( struct MALP_blackboard *bb, uint64_t type, uint64_t *sensivities,
                                                         uint32_t sensivities_count, void (*process)( struct MALP_blackboard *bb, struct Data_entry **de, uint32_t entry_count, void *arg ), void *arg );

void MALP_Blackboard_delete_ks( struct MALP_blackboard *bb, uint64_t type );

int MALP_Blackboard_submit_data( struct MALP_blackboard *bb, uint64_t key, void *payload, size_t payload_size );

int MALP_Blackboard_submit_data_entry(  struct MALP_blackboard *bb, struct Data_entry *de );

int MALP_Blackboard_resubmit_data_entry(  struct MALP_blackboard *bb, struct Data_entry *de );


static inline int MALP_Blackboard_writable_data( struct Data_entry *de )
{

        if( Data_entry_get_ref_count( de ) == 0 )
        {
                return 1;
        }
        else
        {
                return 0;
        }
}

static inline uint64_t MALP_Blackboard_pending( struct MALP_blackboard *bb )
{
    uint64_t ret = 0;

        MALP_Spinlock_lock( &bb->lock );
        ret = bb->pending_datas;
        MALP_Spinlock_unlock( &bb->lock );

    return ret;
}


static inline void MALP_Blackboard_wait_pending( struct MALP_blackboard *bb, uint64_t value )
{
        int got_val = 0;
        
        while( !got_val )
        {
                if( MALP_Blackboard_pending( bb ) == 0 )
                        got_val = 1;
                
                usleep( 1024 );
        }
}


static inline uint64_t MALP_Blackboard_type_hash(uint64_t type)
{
       return MALP_Trace_crc64( (char *)&type, sizeof( uint64_t ) );
}
 
static inline uint64_t MALP_Blackboard_type_state_hash(uint64_t type, uint64_t state)
{
       uint64_t a[2] = {type, state};
       return MALP_Trace_crc64( (char *)a, sizeof( uint64_t ) * 2 );
}


static inline void MALP_Blackboard_add_pending( struct MALP_blackboard *bb)
{
        MALP_Spinlock_lock( &bb->lock );
        bb->pending_datas++;
        MALP_Spinlock_unlock( &bb->lock );
}


static inline void MALP_Blackboard_remove_pending( struct MALP_blackboard *bb)
{
        MALP_Spinlock_lock( &bb->lock );
        bb->pending_datas--;
        MALP_Spinlock_unlock( &bb->lock );
}



/* Export test funcs for tests */
int knowledge_system_test_func(void *pks, uint64_t key, void *arg);

int empty_knowledge_system_test_func(void *pks, uint64_t key, void *arg);

int key_entry_test_func(void *pke, uint64_t key, void *arg);

int empty_key_entry_test_func(void *pke, uint64_t key, void *arg);


#ifdef __cplusplus
}
#endif


#endif