core.h

Go to the documentation of this file.

 
/*
 *   Copyright 2021 Huawei Technologies Co., Ltd.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
 
#ifndef LPFLIB_CORE_H
#define LPFLIB_CORE_H
 
#ifndef DOXYGEN
 
 
// Symbol visibility macros
// slightly adapted copy from https://gcc.gnu.org/wiki/Visibility
//
// Generic helper definitions for shared library support
#if defined _WIN32 || defined __CYGWIN__
  #define _LPFLIB_HELPER_DLL_IMPORT __declspec(dllimport)
  #define _LPFLIB_HELPER_DLL_EXPORT __declspec(dllexport)
  #define _LPFLIB_HELPER_DLL_LOCAL
 
  #define _LPFLIB_HELPER_VAR_IMPORT __declspec(dllimport)
  #define _LPFLIB_HELPER_VAR_EXPORT __declspec(dllexport)
#else
  #if __GNUC__ >= 4
    #define _LPFLIB_HELPER_DLL_IMPORT __attribute__ ((visibility ("default")))
    #define _LPFLIB_HELPER_DLL_EXPORT __attribute__ ((visibility ("default")))
    #define _LPFLIB_HELPER_DLL_LOCAL  __attribute__ ((visibility ("hidden")))
  #else
    #define _LPFLIB_HELPER_DLL_IMPORT
    #define _LPFLIB_HELPER_DLL_EXPORT
    #define _LPFLIB_HELPER_DLL_LOCAL
  #endif
 
  #define _LPFLIB_HELPER_VAR_IMPORT
  #define _LPFLIB_HELPER_VAR_EXPORT
#endif
 
// Now we use the generic helper definitions above to define _LPFLIB_API
// and _LPFLIB_LOCAL. _LPFLIB_API is used for the public API symbols.
// It either DLL imports or DLL exports (or does nothing for static build)
// _LPFLIB_LOCAL is used for non-api symbols.
 
#ifdef _LPFLIB_DLL // defined if _LPFLIB is compiled as a DLL
  #ifdef _LPFLIB_DLL_EXPORTS // defined if we are building the _LPFLIB DLL (instead of using it)
    #define _LPFLIB_API _LPFLIB_HELPER_DLL_EXPORT
    #define _LPFLIB_VAR _LPFLIB_HELPER_VAR_EXPORT
  #else
    #define _LPFLIB_API _LPFLIB_HELPER_DLL_IMPORT
    #define _LPFLIB_VAR _LPFLIB_HELPER_VAR_IMPORT
  #endif // _LPFLIB_DLL_EXPORTS
  #define _LPFLIB_LOCAL _LPFLIB_HELPER_DLL_LOCAL
#else // _LPFLIB_DLL is not defined: this means _LPFLIB is a static lib.
  #define _LPFLIB_API
  #define _LPFLIB_VAR
  #define _LPFLIB_LOCAL
#endif // _LPFLIB_DLL
 
 
#endif // DOXYGEN
 
#include <lpf/static_dispatch.h>
 
 
// import size_t data type for the implementation
#ifndef DOXYGEN
 
#ifdef __cplusplus
#include <cstddef>
#else
#include <stddef.h>
#endif
 
#endif // DOXYGEN
 
 
#ifdef __cplusplus
extern "C" {
#endif
 
#define _LPF_VERSION 202000L
 
#define _LPF_INCLUSIVE_MEMORY 202000L
 
#ifdef DOXYGEN
#define _LPF_EXCLUSIVE_MEMORY 202000L
#endif
 
typedef void * lpf_t;
 
#ifdef DOXYGEN
typedef ... lpf_pid_t;
#else
typedef unsigned lpf_pid_t;
#endif
 
typedef void (*lpf_func_t) ();
 
 
typedef struct lpf_args
{
    const void * input;
 
    size_t input_size;
 
    void * output;
 
    size_t output_size;
 
    const lpf_func_t * f_symbols;
 
    size_t f_size;
 
} lpf_args_t;
 
extern _LPFLIB_VAR const lpf_args_t LPF_NO_ARGS;
 
#ifdef DOXYGEN
typedef ... lpf_err_t;
#else
typedef int lpf_err_t;
#endif
 
extern _LPFLIB_VAR const lpf_err_t LPF_SUCCESS;
 
extern _LPFLIB_VAR const lpf_err_t LPF_ERR_OUT_OF_MEMORY;
 
extern _LPFLIB_VAR const lpf_err_t LPF_ERR_FATAL;
 
#ifdef DOXYGEN
typedef ... lpf_init_t;
#else
typedef void * lpf_init_t;
#endif
 
#ifdef DOXYGEN
typedef ... lpf_sync_attr_t;
#else
typedef int lpf_sync_attr_t;
#endif
 
typedef struct lpf_machine {
 
    lpf_pid_t p;
 
    lpf_pid_t free_p;
 
    double (*g) (lpf_pid_t p, size_t min_msg_size, lpf_sync_attr_t attr);
 
    double (*l) (lpf_pid_t p, size_t min_msg_size, lpf_sync_attr_t attr);
 
} lpf_machine_t;
 
#ifdef DOXYGEN
typedef ... lpf_memslot_t;
#else
 
#ifdef __cplusplus
typedef std::size_t lpf_memslot_t;
#else
typedef size_t lpf_memslot_t;
#endif
 
#endif
 
#ifdef DOXYGEN
typedef ... lpf_msg_attr_t;
#else
typedef int lpf_msg_attr_t;
#endif
 
typedef void(*lpf_spmd_t) ( const lpf_t ctx, const lpf_pid_t pid, const lpf_pid_t nprocs, const lpf_args_t args );
 
 
extern _LPFLIB_VAR const lpf_t LPF_NONE;
 
extern _LPFLIB_VAR const lpf_t LPF_ROOT;
 
extern _LPFLIB_VAR const lpf_init_t LPF_INIT_NONE;
 
extern _LPFLIB_VAR const lpf_sync_attr_t LPF_SYNC_DEFAULT;
 
extern _LPFLIB_VAR const lpf_msg_attr_t LPF_MSG_DEFAULT;
 
extern _LPFLIB_VAR const lpf_pid_t LPF_MAX_P;
 
extern _LPFLIB_VAR const lpf_machine_t LPF_INVALID_MACHINE;
 
extern _LPFLIB_VAR const lpf_memslot_t LPF_INVALID_MEMSLOT;
 
extern _LPFLIB_API
lpf_err_t lpf_exec(
    lpf_t ctx,
    lpf_pid_t P,
    lpf_spmd_t spmd,
    lpf_args_t args
);
 
extern _LPFLIB_API
lpf_err_t lpf_hook(
    lpf_init_t init,
    lpf_spmd_t spmd,
    lpf_args_t args
);
 
extern _LPFLIB_API
lpf_err_t lpf_rehook(
    lpf_t ctx,
    lpf_spmd_t spmd,
    lpf_args_t args
);
 
extern _LPFLIB_API
lpf_err_t lpf_register_global(
    lpf_t ctx,
    void * pointer,
    size_t size,
    lpf_memslot_t * memslot
);
 
extern _LPFLIB_API
lpf_err_t lpf_register_local(
    lpf_t ctx,
    void * pointer,
    size_t size,
    lpf_memslot_t * memslot
);
 
extern _LPFLIB_API
lpf_err_t lpf_deregister(
    lpf_t ctx,
    lpf_memslot_t memslot
);
 
extern _LPFLIB_API
lpf_err_t lpf_put(
    lpf_t ctx,
    lpf_memslot_t src_slot,
    size_t src_offset,
    lpf_pid_t dst_pid,
    lpf_memslot_t dst_slot,
    size_t dst_offset,
    size_t size,
    lpf_msg_attr_t attr
);
 
extern _LPFLIB_API
lpf_err_t lpf_get(
    lpf_t ctx,
    lpf_pid_t src_pid,
    lpf_memslot_t src_slot,
    size_t src_offset,
    lpf_memslot_t dst_slot,
    size_t dst_offset,
    size_t size,
    lpf_msg_attr_t attr
);
 
extern _LPFLIB_API
lpf_err_t lpf_sync( lpf_t ctx, lpf_sync_attr_t attr );
 
extern _LPFLIB_API
lpf_err_t lpf_probe( lpf_t ctx, lpf_machine_t * params );
 
extern _LPFLIB_API
lpf_err_t lpf_resize_memory_register( lpf_t ctx, size_t max_regs );
 
extern _LPFLIB_API
lpf_err_t lpf_resize_message_queue( lpf_t ctx, size_t max_msgs );
 
#ifdef __cplusplus
}
#endif
 
#endif