imd.C File Reference

#include "imd.h"
#include "vmdsock.h"
#include <string.h>
#include <errno.h>
#include <stdlib.h>

Go to the source code of this file.

Classes
struct	IMDheader
union	netint
	structure used to perform byte swapping operations More...

Macros
#define	HEADERSIZE   8
#define	IMDVERSION   2

Functions
static void	swap4 (char *data, int ndata)
static int32	imd_htonl (int32 h)
static int32	imd_ntohl (int32 n)
static void	fill_header (IMDheader *header, IMDType type, int32 length)
static void	swap_header (IMDheader *header)
static int32	imd_readn (void *s, char *ptr, int32 n)
static int32	imd_writen (void *s, const char *ptr, int32 n)
int	imd_disconnect (void *s)
int	imd_pause (void *s)
int	imd_kill (void *s)
static int	imd_go (void *s)
int	imd_handshake (void *s)
int	imd_trate (void *s, int32 rate)
int	imd_send_mdcomm (void *s, int32 n, const int32 *indices, const float *forces)
int	imd_send_energies (void *s, const IMDEnergies *energies)
int	imd_send_fcoords (void *s, int32 n, const float *coords)
IMDType	imd_recv_header_nolengthswap (void *s, int32 *length)
int	imd_recv_handshake (void *s)
	Receive header and data. More...
IMDType	imd_recv_header (void *s, int32 *length)
int	imd_recv_mdcomm (void *s, int32 n, int32 *indices, float *forces)
int	imd_recv_energies (void *s, IMDEnergies *energies)
int	imd_recv_fcoords (void *s, int32 n, float *coords)

Macro Definition Documentation

#define HEADERSIZE   8

Definition at line 14 of file imd.C.

Referenced by imd_disconnect(), imd_go(), imd_handshake(), imd_kill(), imd_pause(), imd_recv_header(), imd_recv_header_nolengthswap(), imd_send_energies(), imd_send_fcoords(), imd_send_mdcomm(), and imd_trate().

#define IMDVERSION   2

Definition at line 15 of file imd.C.

Referenced by imd_handshake(), and imd_recv_handshake().

Function Documentation

static void fill_header ( IMDheader *  header, IMDType  type, int32  length  )

static

Definition at line 60 of file imd.C.

References imd_htonl(), IMDheader::length, and IMDheader::type.

Referenced by imd_disconnect(), imd_go(), imd_handshake(), imd_kill(), imd_pause(), imd_send_energies(), imd_send_fcoords(), imd_send_mdcomm(), and imd_trate().

                                                                       {
  header->type = imd_htonl((int32)type);
  header->length = imd_htonl(length);
}

int imd_disconnect

(

void *

s

)

Definition at line 108 of file imd.C.

References fill_header(), HEADERSIZE, IMD_DISCONNECT, and imd_writen().

                            {
  IMDheader header;
  fill_header(&header, IMD_DISCONNECT, 0);
  return (imd_writen(s, (char *)&header, HEADERSIZE) != HEADERSIZE);
}

static int imd_go ( void *  s )

static

Definition at line 126 of file imd.C.

References fill_header(), HEADERSIZE, IMD_GO, and imd_writen().

Referenced by imd_recv_handshake().

                           {
  IMDheader header;
  fill_header(&header, IMD_GO, 0);
  return (imd_writen(s, (char *)&header, HEADERSIZE) != HEADERSIZE);
}

int imd_handshake

(

void *

s

)

Definition at line 133 of file imd.C.

References fill_header(), HEADERSIZE, IMD_HANDSHAKE, imd_writen(), IMDVERSION, and IMDheader::length.

Referenced by my_imd_connect().

                           {
  IMDheader header;
  fill_header(&header, IMD_HANDSHAKE, 1);
  header.length = IMDVERSION;   // Not byteswapped!
  return (imd_writen(s, (char *)&header, HEADERSIZE) != HEADERSIZE);
}

static int32 imd_htonl ( int32  h )

static

Definition at line 45 of file imd.C.

References netint::b, netint::high, netint::highest, netint::i, netint::low, and netint::lowest.

Referenced by fill_header().

                                {
  netint n;
  n.b.highest = h >> 24;
  n.b.high    = h >> 16;
  n.b.low     = h >> 8;
  n.b.lowest  = h;
  return n.i;
}

int imd_kill

(

void *

s

)

Definition at line 120 of file imd.C.

References fill_header(), HEADERSIZE, IMD_KILL, and imd_writen().

                      {
  IMDheader header;
  fill_header(&header, IMD_KILL, 0);
  return (imd_writen(s, (char *)&header, HEADERSIZE) != HEADERSIZE);
}

static int32 imd_ntohl ( int32  n )

static

Definition at line 54 of file imd.C.

References netint::b, netint::high, netint::highest, netint::i, netint::low, and netint::lowest.

Referenced by swap_header().

                                {
  netint u;
  u.i = n;
  return (u.b.highest << 24 | u.b.high << 16 | u.b.low << 8 | u.b.lowest);
}

int imd_pause

(

void *

s

)

Definition at line 114 of file imd.C.

References fill_header(), HEADERSIZE, IMD_PAUSE, and imd_writen().

                       {
  IMDheader header;
  fill_header(&header, IMD_PAUSE, 0);
  return (imd_writen(s, (char *)&header, HEADERSIZE) != HEADERSIZE);
}

static int32 imd_readn ( void *  s, char *  ptr, int32  n  )

static

Definition at line 70 of file imd.C.

References vmdsock_read().

Referenced by imd_recv_energies(), imd_recv_fcoords(), imd_recv_header(), imd_recv_header_nolengthswap(), and imd_recv_mdcomm().

                                                    {
  int32 nleft;
  int32 nread;
 
  nleft = n;
  while (nleft > 0) {
    if ((nread = vmdsock_read(s, ptr, nleft)) < 0) {
      if (errno == EINTR)
        nread = 0;         /* and call read() again */
      else
        return -1;
    } else if (nread == 0)
      break;               /* EOF */
    nleft -= nread;
    ptr += nread;
  }
  return n-nleft;
}

int imd_recv_energies	(	void *	s,
		IMDEnergies *	energies
	)

Definition at line 231 of file imd.C.

References imd_readn().

Referenced by GlobalMasterIMD::get_vmd_forces().

                                                      {
  return (imd_readn(s, (char *)energies, sizeof(IMDEnergies))
          != sizeof(IMDEnergies));
}

int imd_recv_fcoords	(	void *	s,
		int32	n,
		float *	coords
	)

Definition at line 236 of file imd.C.

References imd_readn().

Referenced by GlobalMasterIMD::get_vmd_forces().

                                                      {
  return (imd_readn(s, (char *)coords, 12*n) != 12*n);
}

int imd_recv_handshake

(

void *

s

)

Receive header and data.

Definition at line 191 of file imd.C.

References imd_go(), IMD_HANDSHAKE, imd_recv_header_nolengthswap(), IMDVERSION, swap4(), and vmdsock_selread().

                                {
  // Wait 5 seconds for the handshake to come
  if (vmdsock_selread(s, 5) != 1) return -1;

  // Check to see that a valid handshake was received
  int32 buf;
  IMDType type = imd_recv_header_nolengthswap(s, &buf);
  if (type != IMD_HANDSHAKE) return -1;

  // Check its endianness, as well as the IMD version.
  if (buf == IMDVERSION) {
    if (!imd_go(s)) return 0;
    return -1;
  }
  swap4((char *)&buf, 4);
  if (buf == IMDVERSION) {
    if (!imd_go(s)) return 1;
  }
  
  // We failed to determine endianness.
  return -1; 
}

IMDType imd_recv_header	(	void *	s,
		int32 *	length
	)

Definition at line 214 of file imd.C.

References HEADERSIZE, IMD_IOERROR, imd_readn(), IMDheader::length, swap_header(), and IMDheader::type.

Referenced by GlobalMasterIMD::get_vmd_forces(), and my_imd_connect().

                                                {
  IMDheader header;
  if (imd_readn(s, (char *)&header, HEADERSIZE) != HEADERSIZE)
    return IMD_IOERROR;
  int i;
  char *ch = (char*)(&header);
  swap_header(&header);
  *length = header.length;
  return IMDType(header.type); 
}

IMDType imd_recv_header_nolengthswap	(	void *	s,
		int32 *	length
	)

Definition at line 182 of file imd.C.

References HEADERSIZE, IMD_IOERROR, imd_readn(), IMDheader::length, swap_header(), and IMDheader::type.

Referenced by imd_recv_handshake().

                                                             {
  IMDheader header;
  if (imd_readn(s, (char *)&header, HEADERSIZE) != HEADERSIZE)
    return IMD_IOERROR;
  *length = header.length;
  swap_header(&header);
  return IMDType(header.type);
}

int imd_recv_mdcomm	(	void *	s,
		int32	n,
		int32 *	indices,
		float *	forces
	)

Definition at line 225 of file imd.C.

References imd_readn().

Referenced by GlobalMasterIMD::get_vmd_forces().

                                                                     {
  if (imd_readn(s, (char *)indices, 4*n) != 4*n) return 1;
  if (imd_readn(s, (char *)forces, 12*n) != 12*n) return 1;
  return 0;
}

int imd_send_energies	(	void *	s,
		const IMDEnergies *	energies
	)

Definition at line 159 of file imd.C.

References fill_header(), HEADERSIZE, IMD_ENERGIES, and imd_writen().

Referenced by GlobalMasterIMD::send_energies().

                                                            {
  int32 size = HEADERSIZE+sizeof(IMDEnergies);
  char *buf = new char[size];
  fill_header((IMDheader *)buf, IMD_ENERGIES, 1);
  memcpy((void *)(buf+HEADERSIZE), (const void *)energies, sizeof(IMDEnergies));
  int rc = (imd_writen(s, buf, size) != size);
  delete [] buf;
  return rc;
}

int imd_send_fcoords	(	void *	s,
		int32	n,
		const float *	coords
	)

Definition at line 169 of file imd.C.

References fill_header(), HEADERSIZE, IMD_FCOORDS, and imd_writen().

Referenced by GlobalMasterIMD::send_fcoords().

                                                            {
  int32 size = HEADERSIZE+12*n;
  char *buf = new char[size];
  fill_header((IMDheader *)buf, IMD_FCOORDS, n);
  memcpy((void *)(buf+HEADERSIZE), (const void *)coords, 12*n);
  int rc = (imd_writen(s, buf, size) != size);
  delete [] buf;
  return rc;
}

int imd_send_mdcomm	(	void *	s,
		int32	n,
		const int32 *	indices,
		const float *	forces
	)

Definition at line 148 of file imd.C.

References fill_header(), HEADERSIZE, IMD_MDCOMM, and imd_writen().

                                                                              {
  int32 size = HEADERSIZE+16*n;
  char *buf = new char[size]; 
  fill_header((IMDheader *)buf, IMD_MDCOMM, n);
  memcpy((void *)(buf+HEADERSIZE), (const void *)indices, 4*n);
  memcpy((void *)(buf+HEADERSIZE+4*n), (const void *)forces, 12*n);
  int rc = (imd_writen(s, buf, size) != size);
  delete [] buf;
  return rc;
}

int imd_trate	(	void *	s,
		int32	rate
	)

Definition at line 140 of file imd.C.

References fill_header(), HEADERSIZE, IMD_TRATE, and imd_writen().

                                   {
  IMDheader header;
  fill_header(&header, IMD_TRATE, rate);
  return (imd_writen(s, (char *)&header, HEADERSIZE) != HEADERSIZE);
}

static int32 imd_writen ( void *  s, const char *  ptr, int32  n  )

static

Definition at line 89 of file imd.C.

References vmdsock_write().

Referenced by imd_disconnect(), imd_go(), imd_handshake(), imd_kill(), imd_pause(), imd_send_energies(), imd_send_fcoords(), imd_send_mdcomm(), and imd_trate().

                                                           {
  int32 nleft;
  int32 nwritten;

  nleft = n;
  while (nleft > 0) {
    if ((nwritten = vmdsock_write(s, ptr, nleft)) <= 0) {
      if (errno == EINTR)
        nwritten = 0;
      else
        return -1;
    }
    nleft -= nwritten;
    ptr += nwritten;
  }
  return n;
}

static void swap4 ( char *  data, int  ndata  )

static

Definition at line 17 of file imd.C.

Referenced by imd_recv_handshake().

                                         {
  int i;
  char *dataptr;
  char b0, b1;

  dataptr = data;
  for (i=0; i<ndata; i+=4) {
    b0 = dataptr[0];
    b1 = dataptr[1];
    dataptr[0] = dataptr[3];
    dataptr[1] = dataptr[2];
    dataptr[2] = b1;
    dataptr[3] = b0;
    dataptr += 4;
  }
}

static void swap_header ( IMDheader *  header )

static

Definition at line 65 of file imd.C.

References imd_ntohl(), IMDheader::length, and IMDheader::type.

Referenced by imd_recv_header(), and imd_recv_header_nolengthswap().

                                           {
  header->type = imd_ntohl(header->type);
  header->length= imd_ntohl(header->length);
}