pvmgetdsig.c

Go to the documentation of this file.

/* $Id: pvmgetdsig.c,v 1.5 2004/08/17 21:15:42 seymour Exp $ */
/* $UTK_Copyright: $ */

/*
 *         PVM version 3.4:  Parallel Virtual Machine System
 *               University of Tennessee, Knoxville TN.
 *           Oak Ridge National Laboratory, Oak Ridge TN.
 *                   Emory University, Atlanta GA.
 *      Authors:  J. J. Dongarra, G. E. Fagg, M. Fischer
 *          G. A. Geist, J. A. Kohl, R. J. Manchek, P. Mucci,
 *         P. M. Papadopoulos, S. L. Scott, and V. S. Sunderam
 *                   (C) 1997 All Rights Reserved
 *
 *                              NOTICE
 *
 * Permission to use, copy, modify, and distribute this software and
 * its documentation for any purpose and without fee is hereby granted
 * provided that the above copyright notice appear in all copies and
 * that both the copyright notice and this permission notice appear in
 * supporting documentation.
 *
 * Neither the Institutions (Emory University, Oak Ridge National
 * Laboratory, and University of Tennessee) nor the Authors make any
 * representations about the suitability of this software for any
 * purpose.  This software is provided ``as is'' without express or
 * implied warranty.
 *
 * PVM version 3 was funded in part by the U.S. Department of Energy,
 * the National Science Foundation and the State of Tennessee.
 */

#include <stdio.h>
#include <stdlib.h>
#include "utility.h"

#ifdef NEEDMENDIAN
#include <machine/endian.h>
#endif
#ifdef NEEDENDIAN
#include <endian.h>
#endif
#ifdef NEEDSENDIAN
#include <sys/endian.h>
#endif

void
printbits(int x)
{
  int i;

  for(i=31;i>=0;i--) {
    printf("%d", (x>>i)&0x1);
    if(i%4==0) printf(" ");
  }
}

/****************************
*  Generate data signature  *
*                           *
****************************/

/* #ifdef   NEEDSFFS */
int
ffs(x)
    int x;
{
    int n = 1, m = 1;

    if (!x)
        return 0;
    while (!(x & m)) {
        m += m;
        n++;
    }
    return n;
}
/* #endif */


static int
ibol(o, p, n)
    int o;
    char *p;
    int n;
{
    int i, j;

    if (p[0] == 0) {
        i = 0;  /* ll */
    } else if (p[0] == n - 1) {
        i = 3;  /* hh */
    } else if (p[0] == n / 2) {
        i = 2;  /* hl */
    } else if (p[0] == n / 2 - 1) {
        i = 1;  /* lh */
    } else {
        fprintf(stderr, "can't generate signature for my integer byte order\n");
        abort();
    }

    j = ffs(n) - 1;
/*
    printf(".%d%d.%d%d%d", (i & 2) ? 1 : 0, (i & 1) ? 1 : 0
            (j & 4) ? 1 : 0, (j & 2) ? 1 : 0, (j & 1) ? 1 : 0);
*/
    return ((i << 3) | j) << o;
}


/*
*  (float)1.0 =
*  IEEE single ll   00 00 80 3f
*  IEEE double ll   00 00 00 00 00 00 f0 3f
*  IEEE single hh   3f 80 00 00
*  IEEE double hh   3f f0 00 00 00 00 00 00
*  CRAY       (hh)  40 01 80 00 00 00 00 00
*  Convex s   (hh)  40 80 00 00
*  Convex d   (hh)  40 10 00 00 00 00 00 00
*  IBM370 s
*  IBM370 d
*  VAX xxxx?
*/

/*
* signatures for float = 1.0 in hh byte order, all formats
*/

unsigned char fs1[] = { 0x3f, 0x80, 0x00, 0x00 };
unsigned char fs2[] = { 0x3f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
unsigned char fs4[] = { 0x40, 0x01, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00 };
unsigned char fs5[] = { 0x40, 0x80, 0x00, 0x00 };
unsigned char fs6[] = { 0x40, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };

struct floatsig thesigs[] = {
    { 0, 0, "UNKNOWN" },
    { 4, fs1, "IEEE_single" },
    { 8, fs2, "IEEE_double" },
    { 0, 0, "UNDEFINED" },
    { 8, fs4, "Cray" },
    { 4, fs5, "Convex_single" },
    { 8, fs6, "Convex_double" },
    { 0, 0, "UNDEFINED" },
    { 0, 0, "UNDEFINED" },
    { 0, 0, "UNDEFINED" },
    { 0, 0, "UNDEFINED" },
    { 0, 0, "UNDEFINED" },
    { 0, 0, "UNDEFINED" },
    { 0, 0, "UNDEFINED" },
    { 0, 0, "UNDEFINED" },
    { 0, 0, "UNDEFINED" },
};


static int
fbol(o, p, n)
    int o;
    unsigned char *p;
    int n;
{
    int i, j;

    for (i = 0; i < 16; i++) {
        if (thesigs[i].length == n) {
            for (j = 0; j < n; j++)
                if (p[j] != thesigs[i].bytes[j])
                    break;
            if (j == n)
                return ((3 << 4) | i) << o;

            for (j = 0; j < n; j++)
                if (p[n - 1 - j] != thesigs[i].bytes[j])
                    break;
            if (j == n)
                return i << o;
        }
    }
    fprintf(stderr, "can't generate signature for my integer byte order\n");
    abort();
    return 0;
}


/*  pvm_getdsig()
*
*   Return data signature for executable, describing representations
*   of integers and floats.
*
*   Bits:
*    0:2  short int size
*    3:4  short int byte order
*    5:7  int size
*    8:9  int byte order
*   10:12  long int size
*   13:14  long int byte order
*   15:18  float format
*   19:20  float byte order
*   21:24  double float format
*   25:26  double float byte order
*   27:31  0
*
*   Sizes are 2 ** (0..7) bytes
*   Byte order specifies overall order and half-folding:
*       00  Little endian (e.g. 0 1 2 3)
*       01  Little, but half-swapped (1 0 3 2 or 3 2 1 0 7 6 5 4)
*       10  Big, but half swapped (2 3 0 1 or 4 5 6 7 0 1 2 3)
*       11  Big endian (3 2 1 0)
*/

int
pvmgetdsig()
{
    static int myfmt = -1;

    short i0;
    int i1;
    long i2;
    float f0;
    double f1;
    int i;
    int fmt;

    if (myfmt != -1)
        return myfmt;

    fmt = 0;

    i0 = 0;
    for (i = 0; i < sizeof(i0); i++)
        i0 += (short)i << (i * 8);
    fmt |= ibol(0, (char *) &i0, (int) sizeof(i0));

    i1 = 0;
    for (i = 0; i < sizeof(i1); i++)
        i1 += (int)i << (i * 8);
    fmt |= ibol(5, (char *) &i1, (int) sizeof(i1));

    i2 = 0;
    for (i = 0; i < sizeof(i2); i++)
        i2 += (long)i << (i * 8);
    fmt |= ibol(10, (char *) &i2, (int) sizeof(i2));

    f0 = 1.0;
    fmt |= fbol(15, (unsigned char *) &f0, (int) sizeof(f0));

    f1 = 1.0;
    fmt |= fbol(21, (unsigned char *) &f1, (int) sizeof(f1));

    myfmt = fmt;
    return fmt;
}