VisionPlus_V3.0/Include/halcon/HParallel.h

/*****************************************************************************
 * HParallel.h
 *****************************************************************************
 *
 * Project:      HALCON/HLib
 * Description:  Basic constants for controlling the automatic
 *               parallelization of HALCON operators and
 *               programs (operator sequences)
 *
 * (c) 1996-2020 by MVTec Software GmbH
 *                  www.mvtec.com
 *
 *****************************************************************************/

#ifndef HCPAR_H
#define HCPAR_H

#if defined(__cplusplus)
extern "C" {
#endif

/* --- Defines -------------------------------------------------- */
#if defined(_POSIX_THREADS)
#  define H_POSIX_THREADS
#elif defined(_WIN32)
#  define H_WIN32_THREADS
#endif
/* else: no synchronization and threads used */


#if !defined(H_PARALLEL) ||                                                   \
    !(defined(H_WIN32_THREADS) || defined(H_POSIX_THREADS))
/* Sequential HALCON or no synchronization specified */
#  define H_NO_SPIN_LOCK
#  if defined H_TSD
#    undef H_TSD /* no thread specific data */
#  endif
#else
#  define H_TSD /* use thread specific data */
#endif


/*===========================================================================*/
/*                                Constants                                  */
/*===========================================================================*/
/* -------- (knowledge default values and control weights) ----------------- */

/* constants for describing how to process an operator:                      */
#define HAG_PAR_INDEPENDENT                                                   \
  0                                /* completely independent of other         \
                                    * operators, i.e., can run with           \
                                    * exclusive operators in parallel*/
#define HAG_PAR_NO_RESTRICT 1 << 0 /* no restriction                 */
#define HAG_PAR_LOCAL 1 << 1       /* force local processing         */
                                   /* by main thread/process         */
#define HAG_PAR_MUTUAL 1 << 2      /* force processing under mutual  */
                                   /* exclusion, i.e. the same       */
                                   /* operator may only run once at  */
                                   /* a time                         */
#define HAG_PAR_EXCLUSIVE 1 << 3   /* force exclusive processing,    */
                                   /* i.e. no other operator may run */
                                   /* while this operator works      */


/* default control values:                                                   */
#define HAG_KW_CHORD_NUM 1     /* minimal num. of chords for par.*/
#define HAG_KW_MIN_COSTS 16300 /* minimal costs for which to par.*/
#define HAG_KW_PAR_COSTS 308   /* weight of ctrl. par. costs     */
#define HAG_KW_CPU_RATING 10   /* threshold for assigning a cpu  */


/* -------- (postprocessing of control parameters) ------------------------- */
#define HAG_PAR_NOCT 1        /* no need of ctrl. par. postproc.*/
                              /* =>adopt par. of 1. H. thread   */
#define HAG_PAR_TUCT_ADD 2    /* add ctrl. par.s ;       tuple  */
#define HAG_PAR_CHCT_ADD 4    /* add ctrl. par.s ;       channel*/
                              /* (must be 2*HAG_PAR_TUCT_ADD)   */
#define HAG_PAR_RECT_ADD 8    /* add ctrl. par.s ;       res.de.*/
                              /* (must be 4*HAG_PAR_TUCT_ADD)   */
#define HAG_PAR_TUCT_MIN 16   /* minimum of ctrl. par.s; tuple  */
#define HAG_PAR_CHCT_MIN 32   /* minimum of ctrl. par.s; channel*/
#define HAG_PAR_RECT_MIN 64   /* minimum of ctrl. par.s; res.de.*/
#define HAG_PAR_TUCT_MAX 128  /* maximum of ctrl. par.s; tuple  */
#define HAG_PAR_CHCT_MAX 256  /* maximum of ctrl. par.s; channel*/
#define HAG_PAR_RECT_MAX 512  /* maximum of ctrl. par.s; res.de.*/
#define HAG_PAR_TUCT_CON 1024 /* concatenate ctrl. par.s;tuple  */
#define HAG_PAR_CHCT_CON 2048 /* concatenate ctrl. par.s;channel*/
#define HAG_PAR_RECT_CON 4096 /* concatenate ctrl. par.s;res.de.*/
                              /* ATTENTION: the difference in   */
                              /* the codes for tuples/channels/ */
                              /* resources must always show the */
                              /* above scheme of *2 and *4!     */
                              /* Because this is used in the    */
                              /* HAgent-source code; e.g.:      */
                              /* HAG_PAR_CHCT_MIN is assumed to */
                              /* be HAG_PAR_TUCT_MIN*2          */
#define HAG_PAR_TUCT 1170     /* postprocess ctrl. par.; tuple  */
/* remark: this is a shortcut for: HAG_PAR_TUCT_ADD | HAG_PAR_TUCT_MIN |     */
/*                                 HAG_PAR_TUCT_MAX | HAG_PAR_TUCT_CON       */
#define HAG_PAR_CHCT 2340 /* postprocess ctrl. par.; channel*/
                          /* (must be 2*HAG_PAR_TUCT)       */
#define HAG_PAR_RECT 4680 /* postprocess ctrl. par.; res.de.*/
                          /* (must be 4*HAG_PAR_TUCT)       */

/* -------- (postprocessing of domains/region components of output objects)  */
#define HAG_PAR_REG_NONE 0          /* no post processing             */
#define HAG_PAR_REG_CONSI (1 << 0)  /* concatenation of (disjuntive)  */
                                    /* result regions for single      */
                                    /* input iconic parameter         */
#define HAG_PAR_REG_CONMU (1 << 1)  /* concatenation of (disjuntive)  */
                                    /* result regions for multiple    */
                                    /* input iconic parameters        */
#define HAG_PAR_REG_CONMAN (1 << 2) /* manual concatenation of        */
                                    /* result regions for multiple    */
                                    /* input iconic parameters        */
                                    /* Use HAG_PAR_REG_CONMAN if your */
                                    /* the output region is variable, */
                                    /* and not dependent on the input */
                                    /* iconic parameters              */

/* -------- (task-/operator-/thread-parallelization; chances and states) --- */
/* -------- (and postprocessing of control parameters) --------------------- */
/* The following constants symbolize different methods of parallelization.   */
/* Their values are built up according to the following rules:               */
/*     Bit  0   signals multithreading ability (see HAG_PAR_MT)              */
/*     Bits 1-6 signal which method of parallelization can be used:          */
#define HAG_PAR_SEQ 0       /* all operators are called       */
                            /* sequentially => no need of     */
                            /* synchronization; no automatic  */
                            /* parallelization                */
#define HAG_PAR_MT (1 << 0) /* "multithreading" context;      */
                            /* operators may called in        */
                            /* parallel use synchronization   */
                            /* mechanisms for reentrancy,     */
                            /* but don't use automatic par.   */
#define HAG_PAR_FORCE                                                         \
  (1 << 1)                    /* force parallelization if                     \
                               * supported */
#define HAG_PAR_NONE (1 << 2) /* no parallelization 'lucrative' */
                              /* is set explicitely, if the
                               * hardware/operator training
                               * showed that the processing does
                               * not speed up by parallelization*/
#define HAG_PAR_TUPL (1 << 5) /* tuple parallelization possible */
#define HAG_PAR_CHNL (1 << 6) /* channel paralleli. is possible */
#define HAG_PAR_RESC (1 << 7) /* resource decomposition possible*/
#define HAG_PAR_REIF (1 << 8) /* res. dec. at image filtering   */
#define HAG_PAR_PART                                                          \
  (1 << 9)                     /* partial automatic parallelization:          \
                                * an operator is parallelized                 \
                                * manually within the hlib */
#define HAG_PAR_PAIF (1 << 10) /* internal domain parallelization */


/* constants for describing the overall processing context:                  */
#define HAG_PAR_SPLIT_NONE 0
#define HAG_PAR_SPLIT_DOMAIN (HAG_PAR_RESC | HAG_PAR_REIF)
/* ^domain parallelization */
#define HAG_PAR_INTERFACE (HAG_PAR_TUPL | HAG_PAR_CHNL | HAG_PAR_REIF)
/* ^parallelization by interface */
#define HAG_PAR_INTERNAL (HAG_PAR_PART | HAG_PAR_PAIF)
/* ^manual, internal parallelization */
#define HAG_PAR_ALL                                                           \
  (HAG_PAR_TUPL | HAG_PAR_CHNL | HAG_PAR_RESC | HAG_PAR_REIF | HAG_PAR_PART | \
   HAG_PAR_PAIF)

/* remark: all following "true" values (!=0) mean in any case that HALCON    */
/* works in a parallel manner and needs synchronization mechanisms           */
#define HAG_PAR_TUPL_MT (HAG_PAR_TUPL | HAG_PAR_MT)
#define HAG_PAR_CHNL_MT (HAG_PAR_CHNL | HAG_PAR_MT)
#define HAG_PAR_RESC_MT (HAG_PAR_RESC | HAG_PAR_MT)
#define HAG_PAR_REIF_MT (HAG_PAR_REIF | HAG_PAR_MT)
#define HAG_PAR_DOM_MT (HAG_PAR_REIF_MT | HAG_PAR_RESC_MT)
#define HAG_PAR_PART_MT (HAG_PAR_PART | HAG_PAR_MT)
#define HAG_PAR_PAIF_MT (HAG_PAR_PAIF | HAG_PAR_MT)

#define HAG_PAR_DPAR_MT                                                       \
  (HAG_PAR_TUPL_MT | HAG_PAR_CHNL_MT | HAG_PAR_RESC_MT | HAG_PAR_REIF_MT |    \
   HAG_PAR_PART_MT | HAG_PAR_PAIF_MT)
/* "multithreading" context (see  */
/* above) AND use automatic       */
/* data parallelization for       */
/* processing operators (default) */

/* tuple & channel p. & res. dec. */
/*     Bits 8-23 currently not used                                          */
/* #define                    128           *                                */
/* #define                    256           *                                */
/* #define                    512           *                                */
/* #define                    1024          *                                */
/* #define                    2048          *                                */
/* #define                    4096          *                                */
/* #define                    8192          *                                */
/* #define                    16384         *                                */
/* #define                    32768         *                                */
/* #define                    65536         *                                */
/* #define                    131072        *                                */
/* #define                    262144        *                                */
/* #define                    524288        *                                */
/* #define                    1048576       *                                */
/* #define                    2097152       *                                */
/* #define                    4194304       *                                */
/*     Bits 24-31 signal which parallelization steps have already been       */
/*     done for the actual task/operator/thread:                             */
#define HAG_PAR_TUPLED (1 << 24) /* tuple parallelized             */
#define HAG_PAR_CHNLED (1 << 25) /* channel parallelized           */
#define HAG_PAR_RESCED (1 << 26) /* resources already decomposed   */
#define HAG_PAR_REIFED (1 << 27) /* res. decom. at image filtering */

/*--------------------    Compute Device constants      ---------------------*/
#define COMPUTE_DEVICE_NONE 0
#define COMPUTE_DEVICE_OpenCL 1

/* H_OPERATOR_INFO.compute_device bit field defines */
#define COMPUTE_DEVICE_BIT_NONE 0
#define COMPUTE_DEVICE_BIT_OpenCL (1 << (COMPUTE_DEVICE_OpenCL))

#if defined(__cplusplus)
}
#endif

#endif