root/opal/dss/dss_compare.c

DEFINITIONS

1. opal_dss_compare
2. opal_dss_compare_int
3. opal_dss_compare_uint
4. opal_dss_compare_size
5. opal_dss_compare_pid
6. opal_dss_compare_byte
7. opal_dss_compare_char
8. opal_dss_compare_int8
9. opal_dss_compare_uint8
10. opal_dss_compare_int16
11. opal_dss_compare_uint16
12. opal_dss_compare_int32
13. opal_dss_compare_uint32
14. opal_dss_compare_int64
15. opal_dss_compare_uint64
16. opal_dss_compare_float
17. opal_dss_compare_double
18. opal_dss_compare_null
19. opal_dss_compare_bool
20. opal_dss_compare_string
21. opal_dss_compare_timeval
22. opal_dss_compare_time
23. opal_dss_compare_dt
24. opal_dss_compare_byte_object
25. opal_dss_compare_pstat
26. opal_dss_compare_node_stat
27. opal_dss_compare_value
28. opal_dss_compare_buffer_contents
29. opal_dss_compare_name
30. opal_dss_compare_vpid
31. opal_dss_compare_jobid
32. opal_dss_compare_status
33. opal_dss_compare_envar

   1 /*
   2  * Copyright (c) 2004-2007 The Trustees of Indiana University and Indiana
   3  *                         University Research and Technology
   4  *                         Corporation.  All rights reserved.
   5  * Copyright (c) 2004-2006 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) 2012      Los Alamos National Security, Inc.  All rights reserved.
  13  * Copyright (c) 2014-2016 Research Organization for Information Science
  14  *                         and Technology (RIST). All rights reserved.
  15  * Copyright (c) 2014-2018 Intel, Inc. All rights reserved.
  16  * $COPYRIGHT$
  17  *
  18  * Additional copyrights may follow
  19  *
  20  * $HEADER$
  21  */
  22 
  23 #include "opal_config.h"
  24 
  25 #include <stdlib.h>
  26 #ifdef HAVE_SYS_TIME_H
  27 #include <sys/time.h> /* for struct timeval */
  28 #endif
  29 
  30 #include "opal/dss/dss_internal.h"
  31 
  32 int opal_dss_compare(const void *value1, const void *value2, opal_data_type_t type)
  33 {
  34     opal_dss_type_info_t *info;
  35 
  36     /* check for error */
  37     if (NULL == value1 || NULL == value2) {
  38         return OPAL_ERR_BAD_PARAM;
  39     }
  40 
  41     /* Lookup the compare function for this type and call it */
  42 
  43     if (NULL == (info = (opal_dss_type_info_t*)opal_pointer_array_get_item(&opal_dss_types, type))) {
  44         return OPAL_ERR_UNKNOWN_DATA_TYPE;
  45     }
  46 
  47     return info->odti_compare_fn(value1, value2, type);
  48 }
  49 
  50 /*
  51  * NUMERIC COMPARE FUNCTIONS
  52  */
  53 int opal_dss_compare_int(int *value1, int *value2, opal_data_type_t type)
  54 {
  55     if (*value1 > *value2) return OPAL_VALUE1_GREATER;
  56 
  57     if (*value2 > *value1) return OPAL_VALUE2_GREATER;
  58 
  59     return OPAL_EQUAL;
  60 }
  61 
  62 int opal_dss_compare_uint(unsigned int *value1, unsigned int *value2, opal_data_type_t type)
  63 {
  64     if (*value1 > *value2) return OPAL_VALUE1_GREATER;
  65 
  66     if (*value2 > *value1) return OPAL_VALUE2_GREATER;
  67 
  68     return OPAL_EQUAL;
  69 }
  70 
  71 int opal_dss_compare_size(size_t *value1, size_t *value2, opal_data_type_t type)
  72 {
  73     if (*value1 > *value2) return OPAL_VALUE1_GREATER;
  74 
  75     if (*value2 > *value1) return OPAL_VALUE2_GREATER;
  76 
  77     return OPAL_EQUAL;
  78 }
  79 
  80 int opal_dss_compare_pid(pid_t *value1, pid_t *value2, opal_data_type_t type)
  81 {
  82     if (*value1 > *value2) return OPAL_VALUE1_GREATER;
  83 
  84     if (*value2 > *value1) return OPAL_VALUE2_GREATER;
  85 
  86     return OPAL_EQUAL;
  87 }
  88 
  89 int opal_dss_compare_byte(char *value1, char *value2, opal_data_type_t type)
  90 {
  91     if (*value1 > *value2) return OPAL_VALUE1_GREATER;
  92 
  93     if (*value2 > *value1) return OPAL_VALUE2_GREATER;
  94 
  95     return OPAL_EQUAL;
  96 }
  97 
  98 int opal_dss_compare_char(char *value1, char *value2, opal_data_type_t type)
  99 {
 100     if (*value1 > *value2) return OPAL_VALUE1_GREATER;
 101 
 102     if (*value2 > *value1) return OPAL_VALUE2_GREATER;
 103 
 104     return OPAL_EQUAL;
 105 }
 106 
 107 int opal_dss_compare_int8(int8_t *value1, int8_t *value2, opal_data_type_t type)
 108 {
 109     if (*value1 > *value2) return OPAL_VALUE1_GREATER;
 110 
 111     if (*value2 > *value1) return OPAL_VALUE2_GREATER;
 112 
 113     return OPAL_EQUAL;
 114 }
 115 
 116 int opal_dss_compare_uint8(uint8_t *value1, uint8_t *value2, opal_data_type_t type)
 117 {
 118     if (*value1 > *value2) return OPAL_VALUE1_GREATER;
 119 
 120     if (*value2 > *value1) return OPAL_VALUE2_GREATER;
 121 
 122     return OPAL_EQUAL;
 123 }
 124 
 125 int opal_dss_compare_int16(int16_t *value1, int16_t *value2, opal_data_type_t type)
 126 {
 127     if (*value1 > *value2) return OPAL_VALUE1_GREATER;
 128 
 129     if (*value2 > *value1) return OPAL_VALUE2_GREATER;
 130 
 131     return OPAL_EQUAL;
 132 }
 133 
 134 int opal_dss_compare_uint16(uint16_t *value1, uint16_t *value2, opal_data_type_t type)
 135 {
 136     if (*value1 > *value2) return OPAL_VALUE1_GREATER;
 137 
 138     if (*value2 > *value1) return OPAL_VALUE2_GREATER;
 139 
 140     return OPAL_EQUAL;
 141 }
 142 
 143 int opal_dss_compare_int32(int32_t *value1, int32_t *value2, opal_data_type_t type)
 144 {
 145     if (*value1 > *value2) return OPAL_VALUE1_GREATER;
 146 
 147     if (*value2 > *value1) return OPAL_VALUE2_GREATER;
 148 
 149     return OPAL_EQUAL;
 150 }
 151 
 152 int opal_dss_compare_uint32(uint32_t *value1, uint32_t *value2, opal_data_type_t type)
 153 {
 154     if (*value1 > *value2) return OPAL_VALUE1_GREATER;
 155 
 156     if (*value2 > *value1) return OPAL_VALUE2_GREATER;
 157 
 158     return OPAL_EQUAL;
 159 }
 160 
 161 int opal_dss_compare_int64(int64_t *value1, int64_t *value2, opal_data_type_t type)
 162 {
 163     if (*value1 > *value2) return OPAL_VALUE1_GREATER;
 164 
 165     if (*value2 > *value1) return OPAL_VALUE2_GREATER;
 166 
 167     return OPAL_EQUAL;
 168 }
 169 
 170 int opal_dss_compare_uint64(uint64_t *value1, uint64_t *value2, opal_data_type_t type)
 171 {
 172     if (*value1 > *value2) return OPAL_VALUE1_GREATER;
 173 
 174     if (*value2 > *value1) return OPAL_VALUE2_GREATER;
 175 
 176     return OPAL_EQUAL;
 177 }
 178 
 179 int opal_dss_compare_float(float *value1, float *value2, opal_data_type_t type)
 180 {
 181     if (*value1 > *value2) return OPAL_VALUE1_GREATER;
 182 
 183     if (*value2 > *value1) return OPAL_VALUE2_GREATER;
 184 
 185     return OPAL_EQUAL;
 186 }
 187 
 188 int opal_dss_compare_double(double *value1, double *value2, opal_data_type_t type)
 189 {
 190     if (*value1 > *value2) return OPAL_VALUE1_GREATER;
 191 
 192     if (*value2 > *value1) return OPAL_VALUE2_GREATER;
 193 
 194     return OPAL_EQUAL;
 195 }
 196 
 197 /*
 198  * NON-NUMERIC SYSTEM TYPES
 199  */
 200 
 201 /* NULL */
 202 int opal_dss_compare_null(char *value1, char *value2, opal_data_type_t type)
 203 {
 204     return OPAL_EQUAL;
 205 }
 206 
 207 /* BOOL */
 208 int opal_dss_compare_bool(bool *value1, bool *value2, opal_data_type_t type)
 209 {
 210     if (*value1 && !(*value2)) return OPAL_VALUE1_GREATER;
 211 
 212     if (*value2 && !(*value1)) return OPAL_VALUE2_GREATER;
 213 
 214     return OPAL_EQUAL;
 215 
 216 }
 217 
 218 /* STRING */
 219 int opal_dss_compare_string(char *value1, char *value2, opal_data_type_t type)
 220 {
 221     if (0 < strcmp(value1, value2)) return OPAL_VALUE2_GREATER;
 222 
 223     if (0 > strcmp(value1, value2)) return OPAL_VALUE1_GREATER;
 224 
 225     return OPAL_EQUAL;
 226 }
 227 
 228 /* TIMEVAL */
 229 int opal_dss_compare_timeval(struct timeval *value1, struct timeval *value2, opal_data_type_t type)
 230 {
 231     if (value1->tv_sec > value2->tv_sec) return OPAL_VALUE1_GREATER;
 232     if (value2->tv_sec > value1->tv_sec) return OPAL_VALUE2_GREATER;
 233 
 234     /* seconds were equal - check usec's */
 235     if (value1->tv_usec > value2->tv_usec) return OPAL_VALUE1_GREATER;
 236     if (value2->tv_usec > value1->tv_usec) return OPAL_VALUE2_GREATER;
 237 
 238     return OPAL_EQUAL;
 239 }
 240 
 241 /* TIME */
 242 int opal_dss_compare_time(time_t *value1, time_t *value2, opal_data_type_t type)
 243 {
 244     if (value1 > value2) return OPAL_VALUE1_GREATER;
 245     if (value2 > value1) return OPAL_VALUE2_GREATER;
 246 
 247     return OPAL_EQUAL;
 248 }
 249 
 250 /* COMPARE FUNCTIONS FOR GENERIC OPAL TYPES */
 251 /* OPAL_DATA_TYPE */
 252 int opal_dss_compare_dt(opal_data_type_t *value1, opal_data_type_t *value2, opal_data_type_t type)
 253 {
 254     if (*value1 > *value2) return OPAL_VALUE1_GREATER;
 255 
 256     if (*value2 > *value1) return OPAL_VALUE2_GREATER;
 257 
 258     return OPAL_EQUAL;
 259 }
 260 
 261 /* OPAL_BYTE_OBJECT */
 262 int opal_dss_compare_byte_object(opal_byte_object_t *value1, opal_byte_object_t *value2, opal_data_type_t type)
 263 {
 264     int checksum, diff;
 265     int32_t i;
 266 
 267     /* compare the sizes first - bigger size object is "greater than" */
 268     if (value1->size > value2->size) return OPAL_VALUE1_GREATER;
 269 
 270     if (value2->size > value1->size) return OPAL_VALUE2_GREATER;
 271 
 272     /* get here if the two sizes are identical - now do a simple checksum-style
 273      * calculation to determine "biggest"
 274      */
 275     checksum = 0;
 276 
 277     for (i=0; i < value1->size; i++) {
 278         /* protect against overflows */
 279         diff = value1->bytes[i] - value2->bytes[i];
 280         if (INT_MAX-abs(checksum)-abs(diff) < 0) { /* got an overflow condition */
 281             checksum = 0;
 282         }
 283         checksum += diff;
 284     }
 285 
 286     if (0 > checksum) return OPAL_VALUE2_GREATER;  /* sum of value2 bytes was greater */
 287 
 288     if (0 < checksum) return OPAL_VALUE1_GREATER;  /* of value1 bytes was greater */
 289 
 290     return OPAL_EQUAL;  /* sum of both value's bytes was identical */
 291 }
 292 
 293 /* OPAL_PSTAT */
 294 int opal_dss_compare_pstat(opal_pstats_t *value1, opal_pstats_t *value2, opal_data_type_t type)
 295 {
 296     return OPAL_EQUAL;  /* eventually compare field to field */
 297 }
 298 
 299 /* OPAL_NODE_STAT */
 300 int opal_dss_compare_node_stat(opal_node_stats_t *value1, opal_node_stats_t *value2, opal_data_type_t type)
 301 {
 302     return OPAL_EQUAL;  /* eventually compare field to field */
 303 }
 304 
 305 /* OPAL_VALUE */
 306 int opal_dss_compare_value(opal_value_t *value1, opal_value_t *value2, opal_data_type_t type)
 307 {
 308     if (NULL == value1 && NULL == value2) {
 309         return OPAL_EQUAL;
 310     }
 311     if (NULL == value2) {
 312         return OPAL_VALUE1_GREATER;
 313     }
 314     if (NULL == value1) {
 315         return OPAL_VALUE2_GREATER;
 316     }
 317     if (value1->type != value2->type) {
 318         opal_output(0, "COMPARE-OPAL-VALUE: INCONSISTENT TYPE %d vs %d", (int)value1->type, (int)value2->type);
 319         return OPAL_EQUAL;
 320     }
 321     switch (value1->type) {
 322     case OPAL_BYTE:
 323         return opal_dss_compare_byte((char *)&value1->data.byte, (char *)&value2->data.byte, type);
 324     case OPAL_STRING:
 325         return opal_dss_compare_string(value1->data.string, value2->data.string, type);
 326     case OPAL_PID:
 327         return opal_dss_compare_pid(&value1->data.pid, &value2->data.pid, type);
 328     case OPAL_INT:
 329         return opal_dss_compare_int(&value1->data.integer, &value2->data.integer, type);
 330     case OPAL_INT8:
 331         return opal_dss_compare_int8(&value1->data.int8, &value2->data.int8, type);
 332     case OPAL_INT16:
 333         return opal_dss_compare_int16(&value1->data.int16, &value2->data.int16, type);
 334     case OPAL_INT32:
 335         return opal_dss_compare_int32(&value1->data.int32, &value2->data.int32, type);
 336     case OPAL_INT64:
 337         return opal_dss_compare_int64(&value1->data.int64, &value2->data.int64, type);
 338     case OPAL_UINT:
 339         return opal_dss_compare_uint(&value1->data.uint, &value2->data.uint, type);
 340     case OPAL_UINT8:
 341         return opal_dss_compare_uint8(&value1->data.uint8, &value2->data.uint8, type);
 342     case OPAL_UINT16:
 343         return opal_dss_compare_uint16(&value1->data.uint16, &value2->data.uint16, type);
 344     case OPAL_UINT32:
 345         return opal_dss_compare_uint32(&value1->data.uint32, &value2->data.uint32, type);
 346     case OPAL_UINT64:
 347         return opal_dss_compare_uint64(&value1->data.uint64, &value2->data.uint64, type);
 348     case OPAL_BYTE_OBJECT:
 349         return opal_dss_compare_byte_object(&value1->data.bo, &value2->data.bo, type);
 350     case OPAL_SIZE:
 351         return opal_dss_compare_size(&value1->data.size, &value2->data.size, type);
 352     case OPAL_FLOAT:
 353         return opal_dss_compare_float(&value1->data.fval, &value2->data.fval, type);
 354     case OPAL_DOUBLE:
 355         return opal_dss_compare_double(&value1->data.dval, &value2->data.dval, type);
 356     case OPAL_BOOL:
 357         return opal_dss_compare_bool(&value1->data.flag, &value2->data.flag, type);
 358     case OPAL_TIMEVAL:
 359         return opal_dss_compare_timeval(&value1->data.tv, &value2->data.tv, type);
 360     case OPAL_NAME:
 361         return opal_dss_compare_name(&value1->data.name, &value2->data.name, type);
 362     case OPAL_ENVAR:
 363         return opal_dss_compare_envar(&value1->data.envar, &value2->data.envar, type);
 364     default:
 365         opal_output(0, "COMPARE-OPAL-VALUE: UNSUPPORTED TYPE %d", (int)value1->type);
 366         return OPAL_EQUAL;
 367     }
 368 }
 369 
 370 /* OPAL_BUFFER */
 371 int opal_dss_compare_buffer_contents(opal_buffer_t *value1, opal_buffer_t *value2, opal_data_type_t type)
 372 {
 373     return OPAL_EQUAL;  /* eventually compare bytes in buffers */
 374 }
 375 
 376 /* OPAL_NAME */
 377 int opal_dss_compare_name(opal_process_name_t *value1,
 378                           opal_process_name_t *value2,
 379                           opal_data_type_t type)
 380 {
 381     if (NULL == value1 && NULL == value2) {
 382         return OPAL_EQUAL;
 383     } else if (NULL == value1) {
 384         return OPAL_VALUE2_GREATER;
 385     } else if (NULL == value2) {
 386         return OPAL_VALUE1_GREATER;
 387     }
 388 
 389     /* If any of the fields are wildcard,
 390     * then we want to just ignore that one field. In the case
 391     * of OPAL_NAME_WILDCARD (where ALL of the fields are wildcard), this
 392     * will automatically result in OPAL_EQUAL for any name in the other
 393     * value - a totally useless result, but consistent in behavior.
 394     */
 395 
 396     /** check the jobids - if one of them is WILDCARD, then ignore
 397     * this field since anything is okay
 398     */
 399     if (value1->jobid != OPAL_JOBID_WILDCARD &&
 400         value2->jobid != OPAL_JOBID_WILDCARD) {
 401         if (value1->jobid < value2->jobid) {
 402             return OPAL_VALUE2_GREATER;
 403         } else if (value1->jobid > value2->jobid) {
 404             return OPAL_VALUE1_GREATER;
 405         }
 406     }
 407 
 408     /** check the vpids - if one of them is WILDCARD, then ignore
 409     * this field since anything is okay
 410     */
 411     if (value1->vpid != OPAL_VPID_WILDCARD &&
 412         value2->vpid != OPAL_VPID_WILDCARD) {
 413         if (value1->vpid < value2->vpid) {
 414             return OPAL_VALUE2_GREATER;
 415         } else if (value1->vpid > value2->vpid) {
 416             return OPAL_VALUE1_GREATER;
 417         }
 418     }
 419 
 420     /** only way to get here is if all fields are equal or WILDCARD */
 421     return OPAL_EQUAL;
 422 }
 423 
 424 int opal_dss_compare_vpid(opal_vpid_t *value1,
 425                           opal_vpid_t *value2,
 426                           opal_data_type_t type)
 427 {
 428     /** if either value is WILDCARD, then return equal */
 429     if (*value1 == OPAL_VPID_WILDCARD ||
 430         *value2 == OPAL_VPID_WILDCARD) return OPAL_EQUAL;
 431 
 432     if (*value1 > *value2) return OPAL_VALUE1_GREATER;
 433 
 434     if (*value2 > *value1) return OPAL_VALUE2_GREATER;
 435 
 436     return OPAL_EQUAL;
 437 }
 438 
 439 int opal_dss_compare_jobid(opal_jobid_t *value1,
 440                            opal_jobid_t *value2,
 441                            opal_data_type_t type)
 442 {
 443     /** if either value is WILDCARD, then return equal */
 444     if (*value1 == OPAL_JOBID_WILDCARD ||
 445         *value2 == OPAL_JOBID_WILDCARD) return OPAL_EQUAL;
 446 
 447     if (*value1 > *value2) return OPAL_VALUE1_GREATER;
 448 
 449     if (*value2 > *value1) return OPAL_VALUE2_GREATER;
 450 
 451     return OPAL_EQUAL;
 452 }
 453 
 454 int opal_dss_compare_status(int *value1, int *value2, opal_data_type_t type)
 455 {
 456     if (*value1 > *value2) return OPAL_VALUE1_GREATER;
 457 
 458     if (*value2 > *value1) return OPAL_VALUE2_GREATER;
 459 
 460     return OPAL_EQUAL;
 461 }
 462 
 463 int opal_dss_compare_envar(opal_envar_t *value1, opal_envar_t *value2, opal_data_type_t type)
 464 {
 465     int rc;
 466 
 467     if (NULL != value1->envar) {
 468         if (NULL == value2->envar) {
 469             return OPAL_VALUE1_GREATER;
 470         }
 471         rc = strcmp(value1->envar, value2->envar);
 472         if (rc < 0) {
 473             return OPAL_VALUE2_GREATER;
 474         } else if (0 < rc) {
 475             return OPAL_VALUE1_GREATER;
 476         }
 477     } else if (NULL != value2->envar) {
 478         /* we know value1->envar had to be NULL */
 479         return OPAL_VALUE2_GREATER;
 480     }
 481 
 482     /* if both are NULL or are equal, then check value */
 483     if (NULL != value1->value) {
 484         if (NULL == value2->value) {
 485             return OPAL_VALUE1_GREATER;
 486         }
 487         rc = strcmp(value1->value, value2->value);
 488         if (rc < 0) {
 489             return OPAL_VALUE2_GREATER;
 490         } else if (0 < rc) {
 491             return OPAL_VALUE1_GREATER;
 492         }
 493     } else if (NULL != value2->value) {
 494         /* we know value1->value had to be NULL */
 495         return OPAL_VALUE2_GREATER;
 496     }
 497 
 498     /* finally, check separator */
 499     if (value1->separator < value2->separator) {
 500         return OPAL_VALUE2_GREATER;
 501     }
 502     if (value2->separator < value1->separator) {
 503         return OPAL_VALUE1_GREATER;
 504     }
 505     return OPAL_EQUAL;
 506 }