root/opal/mca/base/mca_base_component_compare.c

DEFINITIONS

1. mca_base_component_compare_priority
2. mca_base_component_compare
3. mca_base_component_compatible
4. mca_base_component_to_string

   1 /*
   2  * Copyright (c) 2004-2005 The Trustees of Indiana University and Indiana
   3  *                         University Research and Technology
   4  *                         Corporation.  All rights reserved.
   5  * Copyright (c) 2004-2005 The University of Tennessee and The University
   6  *                         of Tennessee Research Foundation.  All rights
   7  *                         reserved.
   8  * Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
   9  *                         University of Stuttgart.  All rights reserved.
  10  * Copyright (c) 2004-2005 The Regents of the University of California.
  11  *                         All rights reserved.
  12  * Copyright (c) 2018      Amazon.com, Inc. or its affiliates.  All Rights reserved.
  13  * $COPYRIGHT$
  14  *
  15  * Additional copyrights may follow
  16  *
  17  * $HEADER$
  18  */
  19 
  20 #include "opal_config.h"
  21 
  22 #include <string.h>
  23 
  24 #include "opal/mca/mca.h"
  25 #include "opal/mca/base/base.h"
  26 #include "opal/util/printf.h"
  27 
  28 /*
  29  * Function for comparing two mca_base_component_priority_t structs so
  30  * that we can build prioritized listss of them.  This assumed that
  31  * the types of the modules are the same.  Sort first by priority,
  32  * second by module name, third by module version.
  33  *
  34  * Note that we acutally want a *reverse* ordering here -- the al_*
  35  * functions will put "smaller" items at the head, and "larger" items
  36  * at the tail.  Since we want the highest priority at the head, it
  37  * may help the gentle reader to consider this an inverse comparison.
  38  * :-)
  39  */
  40 int
  41 mca_base_component_compare_priority(mca_base_component_priority_list_item_t *a,
  42                                     mca_base_component_priority_list_item_t *b)
  43 {
  44   /* First, compare the priorties */
  45 
  46   if (a->cpli_priority > b->cpli_priority) {
  47     return -1;
  48   } else if (a->cpli_priority < b->cpli_priority) {
  49     return 1;
  50   } else {
  51     return mca_base_component_compare(a->super.cli_component,
  52                                       b->super.cli_component);
  53   }
  54 }
  55 
  56 
  57 int mca_base_component_compare(const mca_base_component_t* aa,
  58                                const mca_base_component_t* bb)
  59 {
  60     int val;
  61 
  62     val = strncmp(aa->mca_type_name, bb->mca_type_name,
  63                   MCA_BASE_MAX_TYPE_NAME_LEN);
  64     if (val != 0) {
  65       return -val;
  66     }
  67 
  68     val = strncmp(aa->mca_component_name, bb->mca_component_name,
  69                       MCA_BASE_MAX_COMPONENT_NAME_LEN);
  70     if (val != 0) {
  71       return -val;
  72     }
  73 
  74     /* The names were equal, so compare the versions */
  75 
  76     if (aa->mca_component_major_version >
  77         bb->mca_component_major_version) {
  78       return -1;
  79     } else if (aa->mca_component_major_version <
  80                bb->mca_component_major_version) {
  81       return 1;
  82     } else if (aa->mca_component_minor_version >
  83                bb->mca_component_minor_version) {
  84       return -1;
  85     } else if (aa->mca_component_minor_version <
  86                bb->mca_component_minor_version) {
  87       return 1;
  88     } else if (aa->mca_component_release_version >
  89                bb->mca_component_release_version) {
  90       return -1;
  91     } else if (aa->mca_component_release_version <
  92                bb->mca_component_release_version) {
  93       return 1;
  94     }
  95 
  96     return 0;
  97 }
  98 
  99 
 100 /**
 101  * compare but exclude the release version - declare compatible
 102  * if the major/minor version are the same.
 103  */
 104 int mca_base_component_compatible(
 105     const mca_base_component_t* aa,
 106     const mca_base_component_t* bb)
 107 {
 108     int val;
 109 
 110     val = strncmp(aa->mca_type_name, bb->mca_type_name,
 111                   MCA_BASE_MAX_TYPE_NAME_LEN);
 112     if (val != 0) {
 113       return -val;
 114     }
 115 
 116     val = strncmp(aa->mca_component_name, bb->mca_component_name,
 117                   MCA_BASE_MAX_COMPONENT_NAME_LEN);
 118     if (val != 0) {
 119       return -val;
 120     }
 121 
 122     /* The names were equal, so compare the versions */
 123 
 124     if (aa->mca_component_major_version >
 125         bb->mca_component_major_version) {
 126       return -1;
 127     } else if (aa->mca_component_major_version <
 128                bb->mca_component_major_version) {
 129       return 1;
 130     } else if (aa->mca_component_minor_version >
 131                bb->mca_component_minor_version) {
 132       return -1;
 133     } else if (aa->mca_component_minor_version <
 134                bb->mca_component_minor_version) {
 135       return 1;
 136     }
 137     return 0;
 138 }
 139 
 140 /**
 141  * Returns a string which represents the component name and version.
 142  * Has the form: comp_type.comp_name.major_version.minor_version
 143  */
 144 char * mca_base_component_to_string(const mca_base_component_t *a) {
 145     char * str = NULL;
 146     if(0 > opal_asprintf(&str, "%s.%s.%d.%d", a->mca_type_name,
 147                     a->mca_component_name, a->mca_component_major_version,
 148                     a->mca_component_minor_version)) {
 149         return NULL;
 150     }
 151     return str;
 152 }
 153