malt-wr
collect.h File Reference
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions

SIGNALScollect_pulses_by_voltage (char *filename)
 
SIGNALScollect_pulses_by_phase (char *filename)
 
int collect_values (SIGNALS *sp, char *filename, int collected)
 
int interpolate_phase_thresh_time (SIGNALS *sp_phase)
 
void free_data (SIGNALS *sp)
 
SIGNALScollect_edges (char *filename)
 

Function Documentation

SIGNALS* collect_edges ( char *  filename)

Definition at line 767 of file collect.c.

768 {
769  char voltage_filename[NAME_LENGTH];
770  SIGNALS *sp;
771 
772  strcpy(voltage_filename, filename);
773 
774  sp=collect_pulses(voltage_filename, COLLECT_EDGES);
775 
776 #if 0
777  if(sp!=NULL)
778  if(param.interpolate)
780 #endif
781 
782  return sp;
783 }
#define COLLECT_EDGES
Definition: constype.h:46
int interpolate
Definition: constype.h:99
static SIGNALS * collect_pulses(char *filename, int method)
Definition: collect.c:245
PARAMETERS param
Definition: init.c:10
#define NAME_LENGTH
Definition: constype.h:3
int interpolate_phase_thresh_time(SIGNALS *sp_phase)
Definition: collect.c:693
static char filename[LINE_LENGTH]
Definition: optimize.c:35
SIGNALS* collect_pulses_by_phase ( char *  filename)

Definition at line 750 of file collect.c.

751 {
752  char phase_filename[NAME_LENGTH];
753  SIGNALS *sp;
754 
755  strcpy(phase_filename, filename);
756  strcat(phase_filename, param.phase_ext);
757 
758  sp=collect_pulses(phase_filename, COLLECT_BY_PHASE);
759  if(sp!=NULL)
760  if(param.interpolate)
762 
763  return sp;
764 }
int interpolate
Definition: constype.h:99
static SIGNALS * collect_pulses(char *filename, int method)
Definition: collect.c:245
#define COLLECT_BY_PHASE
Definition: constype.h:44
PARAMETERS param
Definition: init.c:10
#define NAME_LENGTH
Definition: constype.h:3
char phase_ext[NAME_LENGTH]
Definition: constype.h:159
int interpolate_phase_thresh_time(SIGNALS *sp_phase)
Definition: collect.c:693
static char filename[LINE_LENGTH]
Definition: optimize.c:35
SIGNALS* collect_pulses_by_voltage ( char *  filename)

Definition at line 732 of file collect.c.

733 {
734  char phase_filename[NAME_LENGTH];
735  SIGNALS *sp;
736 
738  if(sp!=NULL)
739  {
740  strcpy(phase_filename, filename);
741  strcat(phase_filename, param.phase_ext);
742  if(collect_values(sp, phase_filename, COLLECT_PHASE))
743  verify_phase(sp);
744  }
745 
746  return sp;
747 }
#define COLLECT_PHASE
Definition: constype.h:41
static SIGNALS * collect_pulses(char *filename, int method)
Definition: collect.c:245
PARAMETERS param
Definition: init.c:10
#define COLLECT_BY_VOLTAGE
Definition: constype.h:45
#define NAME_LENGTH
Definition: constype.h:3
static int verify_phase(SIGNALS *sp)
Definition: collect.c:641
int collect_values(SIGNALS *sp, char *filename, int collected)
Definition: collect.c:501
char phase_ext[NAME_LENGTH]
Definition: constype.h:159
static char filename[LINE_LENGTH]
Definition: optimize.c:35
int collect_values ( SIGNALS sp,
char *  filename,
int  collected 
)

Definition at line 501 of file collect.c.

502 {
503  FILE *fp;
504  int i,k,m, sig_nr;
505  PULSE** sig_tmp;
506 
507  int Sdiv3, Smod3;
508 
509  int line_no=0;
510  int signals_in_row, valid_value;
511 
512  double sig_val;
513 
514  int index, old_index=0;
515  float time;
516 
517  fp=fopen(filename, "r");
518  if(fp==NULL)
519  return 0;
520 
521 /* skip number of signals traced */
522  read_line(fp, line, &line_no);
523 
524 /* skip the number of the input with variable generator attached */
525  read_line(fp, line, &line_no);
526 
527 /* skip the names of signals given by the designer */
528  read_line(fp, line, &line_no);
529 
530 /* read the names of signals used in jspice simulations */
531  switch(collected)
532  {
533  case COLLECT_PHASE:
534  sp->jspice_phase_names=(char (*)[NAME_LENGTH])calloc(sp->signal_num,
535  NAME_LENGTH*sizeof(char));
536  break;
537 
538  case COLLECT_VOLTAGE:
539  sp->jspice_voltage_names=(char (*)[NAME_LENGTH])calloc(sp->signal_num,
540  NAME_LENGTH*sizeof(char));
541  break;
542  }
543 
544  read_line(fp, line, &line_no);
545  k=0;
546  for(m=0; m<sp->signal_num; m++)
547  {
548  if(collected==COLLECT_PHASE)
549  i=sscanf(&line[k], "%s", sp->jspice_phase_names[m]);
550 
551  if(collected==COLLECT_VOLTAGE)
552  i=sscanf(&line[k], "%s", sp->jspice_voltage_names[m]);
553 
554  if(i!=1)
555  {
556  printf("ERROR IN LINE: %d\n", line_no);
557  return 0;
558  }
559  k+=skip_arg(&line[k], 1);
560  }
561 
562 
563  sig_tmp=(PULSE**) calloc(sp->signal_num, sizeof(PULSE*));
564  for(k=0; k<sp->signal_num; k++)
565  sig_tmp[k]=sp->sig_bgn[k];
566 
567  Sdiv3=sp->signal_num/3;
568  Smod3=sp->signal_num%3;
569  if(Smod3!=0)
570  Sdiv3++;
571  else
572  Smod3=3;
573 
574  signals_in_row = 3;
575 
576  for(i=0; i<=Sdiv3; i++)
577  {
578  if(i==Sdiv3)
579  signals_in_row=Smod3;
580  while(read_line(fp, line, &line_no))
581  {
582  if(sscanf(line, "%d %e", &index, &time)!=2)
583  continue;
584  if(index!=old_index+1)
585  if(index==0)
586  {
587  old_index=0;
588  goto next_signals;
589  }
590  else
591  continue;
592  old_index=index;
593 
594  valid_value=0;
595  for(m=0; m<signals_in_row; m++)
596  {
597  sig_nr = (i-1)*3+m;
598  if(sig_tmp[sig_nr]!=NULL)
599  if(time==sig_tmp[sig_nr]->t)
600  valid_value=1;
601  }
602 
603  if(!valid_value)
604  continue;
605 
606  k=skip_arg(line, 2);
607 
608  for(m=0; m<signals_in_row; m++)
609  {
610  if(sscanf(&line[k], "%le", &sig_val)!=1)
611  break;
612 
613  sig_nr = (i-1)*3+m;
614  if(sig_tmp[sig_nr]!=NULL)
615  if(time==sig_tmp[sig_nr]->t)
616  {
617  switch(collected)
618  {
619  case COLLECT_PHASE:
620  sig_tmp[sig_nr]->phase=sig_val;
621  break;
622 
623  case COLLECT_VOLTAGE:
624  sig_tmp[sig_nr]->val=sig_val;
625  break;
626  }
627  sig_tmp[sig_nr]=sig_tmp[sig_nr]->next;
628  }
629  k+=skip_arg(&line[k], 1);
630  }
631  }
632 next_signals: ;
633  }
634 
635  fclose(fp);
636  return 1;
637 }
#define COLLECT_PHASE
Definition: constype.h:41
struct PULSE_DESC * next
Definition: constype.h:298
PULSE ** sig_bgn
Definition: constype.h:404
char(* jspice_phase_names)[NAME_LENGTH]
Definition: constype.h:387
int skip_arg(char *line, int arg_num)
Definition: lineread.c:54
int signal_num
Definition: constype.h:366
static int read_line(FILE *fp, char *line, int *line_no)
Definition: collect.c:10
#define NAME_LENGTH
Definition: constype.h:3
static char line[LONG_LINE_LENGTH]
Definition: collect.c:7
char(* jspice_voltage_names)[NAME_LENGTH]
Definition: constype.h:384
static char filename[LINE_LENGTH]
Definition: optimize.c:35
PHASE phase
Definition: constype.h:288
double val
Definition: constype.h:287
#define COLLECT_VOLTAGE
Definition: constype.h:42
void free_data ( SIGNALS sp)

Definition at line 787 of file collect.c.

788 {
789  int i;
790  PULSE *pp, *ppf;
791  ASYNC_CHECK *tmp_check, *next_check;
792 
793  if(sp==NULL)
794  return;
795 
796  for(i=0; i<sp->signal_num; i++)
797  {
798 /* SRW ** error here, these are not atomically allocated.
799  if(sp->signal_names!=NULL)
800  free(sp->signal_names[i]);
801  if(sp->jspice_voltage_names!=NULL)
802  free(sp->jspice_voltage_names[i]);
803  if(sp->jspice_phase_names!=NULL)
804  free(sp->jspice_phase_names[i]);
805 */
806  if(sp->sig_log!=NULL)
807  free(sp->sig_log[i]);
808 
809  if(sp->sig_bgn!=NULL)
810  {
811  pp=sp->sig_bgn[i];
812  while(pp!=NULL)
813  {
814  ppf=pp;
815  pp=pp->next;
816  free(ppf);
817  }
818  }
819  }
820 
821  next_check=tmp_check=sp->async_check_list;
822  while(tmp_check!=NULL)
823  {
824  next_check=tmp_check->next;
825  free(tmp_check);
826  tmp_check=next_check;
827  }
828 
829  free(sp->signal_names);
830  free(sp->jspice_voltage_names);
831  free(sp->jspice_phase_names);
832  free(sp->sig_log);
833  free(sp->sig_bgn);
834 
835  free(sp->current_phase);
836  free(sp->last_index);
837  free(sp->clk_times);
838  free(sp->check_index);
839 }
TIME * clk_times
Definition: constype.h:431
struct async_checkpoint * next
Definition: constype.h:353
struct PULSE_DESC * next
Definition: constype.h:298
int * last_index
Definition: constype.h:428
int * check_index
Definition: constype.h:444
PULSE ** sig_bgn
Definition: constype.h:404
char(* jspice_phase_names)[NAME_LENGTH]
Definition: constype.h:387
int signal_num
Definition: constype.h:366
char(* signal_names)[NAME_LENGTH]
Definition: constype.h:381
PHASE * current_phase
Definition: constype.h:424
LOGIC ** sig_log
Definition: constype.h:439
char(* jspice_voltage_names)[NAME_LENGTH]
Definition: constype.h:384
ASYNC_CHECK * async_check_list
Definition: constype.h:458
int interpolate_phase_thresh_time ( SIGNALS sp_phase)

Definition at line 693 of file collect.c.

694 {
695  int k;
696  PULSE *pp_phase;
697  FILE *fp;
698 
699  TIME t10delta;
700  PHASE p10delta, pt0delta;
701 
702 
703  for(k=0; k<sp_phase->signal_num; k++)
704  {
705  pp_phase=sp_phase->sig_bgn[k];
706 
707  while(pp_phase!=NULL)
708  {
709  p10delta = pp_phase->p_above-pp_phase->p_below;
710  if(p10delta>0)
711  {
712  pt0delta = pp_phase->norm_phase + param.nom_phase_thresh -
713  pp_phase->p_below;
714  t10delta = pp_phase->t_above - pp_phase->t_below;
715  pp_phase->t= t10delta*(pt0delta/p10delta) + pp_phase->t_below;
716  }
717  else
718  if(pp_phase->t_above == pp_phase->t_below)
719  pp_phase->t=pp_phase->t_above;
720  else
721  pp_phase->t=(pp_phase->t_above + pp_phase->t_below)/2;
722  pp_phase->phase=pp_phase->norm_phase + param.nom_phase_thresh;
723  pp_phase=pp_phase->next;
724  }
725  }
726 
727  return 1;
728 }
struct PULSE_DESC * next
Definition: constype.h:298
TIME t
Definition: constype.h:284
PULSE ** sig_bgn
Definition: constype.h:404
int signal_num
Definition: constype.h:366
PARAMETERS param
Definition: init.c:10
PHASE p_above
Definition: constype.h:295
PHASE nom_phase_thresh
Definition: constype.h:82
float PHASE
Definition: constype.h:55
TIME t_above
Definition: constype.h:293
PHASE p_below
Definition: constype.h:294
float TIME
Definition: constype.h:54
PHASE phase
Definition: constype.h:288
TIME t_below
Definition: constype.h:292
PHASE norm_phase
Definition: constype.h:291