simpsim.c

basic.c */ /**//* Project:NeuroBasic, basic package*//**/ /* Survey:This is a simple Basic b-code

/****************************************************************/
/*								*/
/* Name:	simpsim.c (Simple MUSIC Simulator)		*/
/*								*/
/* Project:	Simple Simulation of MUSIC operating system	*/
/*								*/
/* Survey:	This file can be linked (as library) to a	*/
/*		MUSIC C sourcecode (host- and DSP-code) to	*/
/*		make a standallone program, running on a	*/
/*		single processor machine.			*/
/*								*/
/* Author:	Urs Mueller Laboratory, ETH Zuerich,		*/
/*		Switzerland					*/
/*								*/
/* Created:	August 13, 1992					*/
/* Modified:	January 26, 1995 (mk)				*/
/*								*/
/****************************************************************/


/****************************************************************/
/* Common Part: DSP and Host Operating System			*/
/****************************************************************/

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <setjmp.h>
#include <stdarg.h>
#include <musiclib.h>
#include "common.h"

#ifdef VAXC
#include <signal.h>
#endif




/* global variables */
/********************/

jmp_buf	env_pe;
jmp_buf	env_host;




/****************************************************************/
/* DSP Operating System						*/
/****************************************************************/

#include <musiclib.h>
#include <mdisk.h>


#define	MDISK_UNDEFINED	0 /* Undefined IO of disk of host  */
#define	MDISK_READ	1 /* Read from disk of host instead of mdisk */
#define MDISK_WRITE	2 /* Write to disk of host instead of mdisk  */


/* global variables */
/********************/

MINT		NumDSPs = 1;
MINT		MyDSPnum = 0;
MINT		__Mretcode;




/* static variables */
/********************/

static MINT	g_nelements;
static size_t	g_elem_size;
static MINT	g_nelem_copied;
static char	*g_pprod;
static char	*g_pcons;
static MINT	g_nodistr_flag;
static MINT	g_mdisk_flag = MDISK_UNDEFINED;
static char	*g_mdisk_buffer;
static FILE	*g_mdisk_fpt;



void Init_comm(pcomm_def, pprod, pcons, comm_mode)
/************************************************/
/* Communication with imagined MDISK allows only that the HOLE
   communication block is sent/get to/from disk. ==> Windows has 
   to be completed with Complete_..._window(..,NO_DISTR) or
   Complete_..._window(..,ALL_DISTR).
*/

comm_def_t *pcomm_def;
void *pprod, *pcons;
comm_mode_t comm_mode;
{
  comm_mode = comm_mode;	/* to suppress compiler warnings */
  g_nelements = pcomm_def->dim.x * pcomm_def->dim.y * pcomm_def->dim.z;
  g_elem_size = pcomm_def->elem_size;
  g_nelem_copied = 0;
  if (pcomm_def->cons.nelements > 0)
    g_nodistr_flag = FALSE;
  else				/* patch for the case of.. */
    g_nodistr_flag = TRUE;	/* ..zero data reception   */

  if (g_mdisk_flag == MDISK_READ)  /* communication from disk */ 
  {   
    g_pprod = g_mdisk_buffer;
    g_pcons = (char*)pcons;
    Data_ready(ALL_DATA);
  }
  else if (g_mdisk_flag == MDISK_WRITE) /* communication to disk */    
  {
    g_pprod = (char*)pprod;
    g_pcons = g_mdisk_buffer;
    Data_ready(ALL_DATA);
  }
  else
  {
    g_pprod = (char*)pprod;
    g_pcons = (char*)pcons;
  }

  if (g_pprod == HOST_IO)
    Wait_data(ALL_DATA);		/* communication from host */
} /* end of Init_comm() */




void Data_ready(nelements)
/************************/
MINT nelements;
{
  long	nnewelem;
  long  read; 

  nnewelem = (nelements == ALL_DATA ? g_nelements : nelements)
             - g_nelem_copied;
  if (nnewelem <= 0) return;			/* do nothing */

  if (g_mdisk_flag == MDISK_READ)
  {
    read = fread(g_mdisk_buffer, g_elem_size, nnewelem, g_mdisk_fpt);
    if (read != nnewelem && (nnewelem - read > MDISK_BLOCKSIZE))
    {
      printf("COMMUNICATION ERROR: Could not read");
      printf(" all required data from disk\n");
      return;
    }
    memcpy(g_pcons + g_nelem_copied * g_elem_size,
	   g_mdisk_buffer, nnewelem * g_elem_size);
    g_nelem_copied += nnewelem;
    if (g_nelem_copied >= g_nelements)
    {
      g_mdisk_flag = MDISK_UNDEFINED;
      free(g_mdisk_buffer);
    }
    return;
  }
  

  if (g_mdisk_flag == MDISK_WRITE)
  {
    memcpy(g_mdisk_buffer, g_pprod + g_nelem_copied * g_elem_size,
	   nnewelem * g_elem_size);
    if (fwrite(g_mdisk_buffer, g_elem_size, nnewelem, g_mdisk_fpt) != 
	nnewelem)
    {
      printf("COMMUNICATION ERROR: Could not write");
      printf(" all required data to disk\n");
      return;
    }
    g_nelem_copied += nnewelem;
    if (g_nelem_copied >= g_nelements)
    {
      g_mdisk_flag = MDISK_UNDEFINED;
      free(g_mdisk_buffer);
    }
    return;
  }


  if (g_pcons != HOST_IO && g_pprod != HOST_IO)
  {					/* communicate to PE */
    if (!g_nodistr_flag)
    {
      memcpy(g_pcons + g_nelem_copied * g_elem_size,
	     g_pprod + g_nelem_copied * g_elem_size,
	     nnewelem * g_elem_size);
    }
    g_nelem_copied += nnewelem;
  }
  else if (g_pprod != HOST_IO)
  {					/* communicate to host */
    if (setjmp(env_pe) == 0)
    {
      longjmp(env_host, 1);
    }
  }
} /* end of Data_ready() */




MINT Wait_data(MINT nelements)
/****************************/
{
  if (nelements == ALL_DATA) nelements = g_nelements;
  if (nelements > g_nelem_copied)
  {
    if (g_mdisk_flag == MDISK_READ || g_mdisk_flag == MDISK_WRITE)
      Data_ready(nelements);

    if (g_pprod == HOST_IO && setjmp(env_pe) == 0)
    {
      longjmp(env_host, 1);
    }
  } 
  return g_nelem_copied;
} /* end of Wait_data() */




void Rd_from_host(buf, size, mode)
/********************************/
void *buf;
size_t size;
RFH_t mode;
{
  mode = mode;			/* to suppress compiler warnings */
  g_nelements = size;
  g_nodistr_flag = FALSE;
  g_elem_size = 1;
  g_nelem_copied = 0;
  g_pprod = HOST_IO;
  g_pcons = (char*)buf;

  Wait_data(ALL_DATA);
} /* end of Rd_from_host() */




void Wr_to_host(buf, size, mode)
/******************************/
void *buf;
size_t size;
WTH_t mode;
{
  mode = mode;			/* to suppress compiler warnings */
  g_nelements = size;
  g_nodistr_flag = FALSE;
  g_elem_size = 1;
  g_nelem_copied = 0;
  g_pprod = (char*)buf;
  g_pcons = HOST_IO;

  Data_ready(ALL_DATA);
} /* end of Wr_to_host() */




void Window_generator(pcomm_def, pss_def, NumDSPs, MyDSPnum, distr,
                      overlap_x, overlap_y, overlap_z)
/*****************************************************************/
comm_def_t   *pcomm_def;
window_t     *pss_def;	  		/* prod or cons of */
MINT	     NumDSPs;
MINT	     MyDSPnum;
distr_t      distr;
MINT	     overlap_x;
MINT	     overlap_y;
MINT	     overlap_z;
{
NumDSPs = NumDSPs;		/* to suppress compiler warnings */
MyDSPnum = MyDSPnum;		/* to suppress compiler warnings */
overlap_x = overlap_x;		/* to suppress compiler warnings */
overlap_y = overlap_y;		/* to suppress compiler warnings */
overlap_z = overlap_z;		/* to suppress compiler warnings */

if (distr != NO_DISTR)
  {
  pss_def->offset.x = 0;
  pss_def->offset.y = 0;
  pss_def->offset.z = 0;
  pss_def->part.x = pcomm_def->dim.x;
  pss_def->part.y = pcomm_def->dim.y;
  pss_def->part.z = pcomm_def->dim.z;
  pss_def->nelements = pcomm_def->dim.x * pcomm_def->dim.y
                       * pcomm_def->dim.z;
  }
else
  {
  pss_def->offset.x = pcomm_def->dim.x;
  pss_def->offset.y = pcomm_def->dim.y;
  pss_def->offset.z = pcomm_def->dim.z;
  pss_def->part.x = 0;
  pss_def->part.y = 0;
  pss_def->part.z = 0;
  pss_def->nelements = 0;
  }
} /* end of Window_generator */



void Distr_one_dim(ppart, poffset, NumDSPs, MyDSPnum, dim, overlap)
/*****************************************************************/
MINT   *ppart;		/* returns part and offset */
MINT   *poffset;		/* of distributed dimension. */
MINT   NumDSPs;
MINT   MyDSPnum;
MINT   dim;
MINT   overlap;		/* overlap in number of elements */
{
NumDSPs = NumDSPs;		/* to suppress compiler warnings */
MyDSPnum = MyDSPnum;		/* to suppress compiler warnings */
overlap = overlap;		/* to suppress compiler warnings */

*ppart = dim;
*poffset = 0;
} /* end of Distr_one_dim() */




void *dmalloc(size, mem)
/**********************/
size_t size;
mem_t mem;
{
if (mem != MT_INIT)		/* to suppress compiler warnings */
  return (void*)malloc(size);
else
  return NULL;
} /* end of dmalloc() */




void *dcalloc(nitems, size, mem)
/******************************/
MINT nitems;
size_t size;
mem_t mem;
{
mem = mem;			/* to suppress compiler warnings */
return (void*)calloc(nitems, size);
} /* end of dcalloc() */




void *drealloc(block, newsize, mem)
/*********************************/
void *block;
size_t newsize;
mem_t mem;
{
mem = mem;			/* to suppress compiler warnings */
return (void*)realloc(block, newsize);
} /* end of drealloc() */




void dfree(block)
/***************/
void *block;
{
free(block);
} /* end of dfree() */




void dstrategy(mems_t strategy)
/*****************************/
{
} /* end of dstrategy() */




void dpriority(memp_t priority)
/*****************************/
{
} /* end of dpriority() */




MFILE *MDISK_open(MINT MDISK_board, char *filename, ...)
/*****************************************************/
/* opens the file filename on the host. MDISK_board, and the 
   optional parameter have no effect. */
{

  va_list	ap;
  FILE		*fpt;

  va_start(ap, filename);
  va_end(ap);

  fpt = fopen(filename, "rb");
  return (MFILE*) fpt;

} /* end of MDISK_open() */




void MDISK_close(MFILE *mdfile)
/*******************************/
/* close the file on where mdfile points to */
{
  fclose((FILE*)mdfile);

} /* end of MDISK_close() */




void Set_comm_MDISK_window(MFILE *mdfpt, comm_def_t *pwindow,
			   MDISK_MODE_t mode, UMINT offset)
/***********************************************************/
{
  MINT		allocsize;

  if (mdfpt)
  {
    g_mdisk_fpt = (FILE*) mdfpt;
    allocsize = (*pwindow).prod.nelements * (*pwindow).elem_size;
    if (allocsize)
      g_mdisk_flag = MDISK_READ;
    else 
    {
      allocsize = (*pwindow).cons.nelements * (*pwindow).elem_size;
      if (allocsize)
	g_mdisk_flag = MDISK_WRITE;
      else 
	g_mdisk_flag = MDISK_UNDEFINED;
    }

    if (allocsize)
    {
      g_mdisk_buffer = (char*) malloc(allocsize);
      if (g_mdisk_buffer == NULL)
      { 
        printf("COMMUNICATION ERROR: Not enough memory on host");
        printf(" to allocate disk buffer.\n");
	return;
      }

      if (fseek(g_mdisk_fpt, offset*sizeof(UMINT), SEEK_SET) != NULL)
      {
	printf("COMMUNICATION ERROR: Can not position file");
        printf(" pointer on file.\n");
        return;
      }
    }
  }

  else 
  {
    printf("COMMUNICATION ERROR: No file opened\n");
    return;
  }
  
} /* end of Set_comm_MDISK_window() */


 

MINT MDISK_get_numboards(void)
/****************************/
{
  return 1;  /* local version uses the normal file 
                systems instead of MDISK */
    
} /* end of MDISK_get_numboards() */




MINT MDISK_init(MINT MDISK_boardnum)
/**********************************/
{
  return 1;  /* local version uses the normal file 
                systems instead of MDISK */
    
} /* end of MDISK_init() */


/****************************************************************/
/* Host Operating System					*/
/****************************************************************/

#include <m_host.h>




MINT WAIT_FCT()
/*************/
{
return __Mretcode;
} /* end of WAIT_FCT() */




#ifdef VAXC
int exception_handler(void *sigarr, void *mecharr)
/*==============================================*/
{
  return 0;		/* just a dummy function */
} /* end of exception_handler() */
#endif /* VAXC */



int INIT_MUSIC()
/**************/
{
#ifdef VAXC
  VAXC$ESTABLISH(exception_handler);	/* needed for setjmp() */
#endif

  return TRUE;
} /* end of INIT_MUSIC() */




int BOOT_DSPs(filename)
/*********************/
char *filename;
{
  if (*filename == 0)
    *filename = 0;	/* to suppress compiler warnings */
  return TRUE;
} /* end of BOOT_DSPs() */




void EXIT_MUSIC()
/***************/
{
} /* end of EXIT_MUSIC() */




void Wr_to_music(p, size)
/***********************/
void *p;
long size;					/* in "bytes" */
{
  if (size <= 0) return;			/* do nothing */
  if (!g_nodistr_flag)
    memcpy(g_pcons + g_nelem_copied * g_elem_size, p, size);
  g_nelem_copied += size / g_elem_size;
  
  if (setjmp(env_host) == 0)
  {
    if (g_nelem_copied >= g_nelements) longjmp(env_pe, 1);
  }
} /* end of Wr_to_music() */




void Rd_from_music(p, size)
/*************************/
void *p;
long size;
{
  if (size <= 0) return;			/* do nothing */
  memcpy(p, g_pprod + g_nelem_copied * g_elem_size, size);
  g_nelem_copied += size / g_elem_size;
  
  if (setjmp(env_host) == 0)
  {
    if (g_nelem_copied >= g_nelements) longjmp(env_pe, 1);
  }
} /* end of Rd_from_music() */