Example #1
0
int main (int argc, char ** argv) {
  int i, len, ch, close = 0, res, arg;
  char buffer[80], * tok, * opt;
  FILE * file;
  char * cmd;
  LGL * lgl;
  for (i = 1; i < argc; i++) {
    if (!strcmp (argv[i], "-h")) {
      printf ("usage: lgluntrace [-h][-v][-e][<trace>[.gz]]\n");
      exit (0);
    } else if (!strcmp (argv[i], "-v")) verbose = 1;
    else if (!strcmp (argv[i], "-e")) exitonabort = 1;
    else if (argv[i][0] == '-')
      die ("invalid command line option '%s' (try '-h')", argv[i]);
    else if (name)
      die ("two traces '%s' and '%s' specified (try '-h')", name, argv[i]);
    else name = argv[i];
  }
  if(name) {
    len = strlen (name);
    if (len >= 3 && !strcmp (name + len - 3, ".gz")) {
      cmd = malloc (len + 20);
      sprintf (cmd, "gunzip -c %s", name);
      file = popen (cmd, "r");
      free (cmd);
      if (file) close = 2;
    } else {
      file = fopen (name, "r");
      if (file) close = 1;
    }
    if (!file) die ("can not read '%s'", name);
  } else name = "<stdin>", file = stdin;
  if (exitonabort) {
    msg ("setting signal handlers since '-e' specified");
    signal (SIGINT, exitonsig);
    signal (SIGSEGV, exitonsig);
    signal (SIGABRT, exitonsig);
    signal (SIGTERM, exitonsig);
  }
  msg ("reading %s", name);
  buffer[len = 0] = 0;
  lineno = 1;
  res = 0;
  lgl = 0;
NEXT:
  ch = getc (file);
  if (ch == EOF) goto DONE;
  if (ch == '\r') goto NEXT;
  if (ch != '\n') {
    if (len + 1 >= sizeof (buffer)) perr ("line buffer exceeded");
    buffer[len++] = ch;
    buffer[len] = 0;
    goto NEXT;
  }
  msg ("line %d : %s", lineno, buffer);
  if (!(tok = strtok (buffer, " "))) perr ("empty line");
  else if (!strcmp (tok, "add")) lgladd (lgl, intarg ("add"));
  else if (!strcmp (tok, "return")) {
    arg = intarg ("return");
    if (arg != res) 
      die ("expected return value %d but got %d", arg, res);
  } else if (!strcmp (tok, "deref")) res = lglderef (lgl, intarg ("deref"));
  else if (!strcmp (tok, "failed")) res = lglfailed (lgl, intarg ("failed"));
  else if (!strcmp (tok, "fixed")) res = lglfixed (lgl, intarg ("fixed"));
  else if (!strcmp (tok, "repr")) res = lglrepr (lgl, intarg ("repr"));
  else if (noarg (tok, "incvar")) res = lglincvar (lgl);
  else if (noarg (tok, "maxvar")) res = lglmaxvar (lgl);
  else if (noarg (tok, "changed")) res = lglchanged (lgl);
  else if (noarg (tok, "inconsistent")) res = lglinconsistent (lgl);
  else if (noarg (tok, "lkhd")) res = lglookahead (lgl);
  else if (noarg (tok, "fixate")) lglfixate (lgl);
  else if (noarg (tok, "reduce")) lglreducecache (lgl);
  else if (noarg (tok, "flush")) lglflushcache (lgl);
  else if (noarg (tok, "chkclone")) lglchkclone (lgl);
  else if (!strcmp (tok, "assume")) lglassume (lgl, intarg ("assume"));
  else if (noarg (tok, "init")) lgl = lglinit ();
  else if (noarg (tok, "sat")) res = lglsat (lgl);
  else if (!strcmp (tok, "simp")) res = lglsimp (lgl, intarg ("simp"));
  else if (noarg (tok, "stats")) lglstats (lgl);
  else if (!strcmp (tok, "freeze")) lglfreeze (lgl, intarg ("freeze"));
  else if (!strcmp (tok, "melt")) lglmelt (lgl, intarg ("melt"));
  else if (!strcmp (tok, "reuse")) lglreuse (lgl, intarg ("reuse"));
  else if (!strcmp (tok, "frozen")) res = lglfrozen (lgl, intarg ("frozen"));
  else if (!strcmp (tok, "usable")) res = lglusable (lgl, intarg ("usable"));
  else if (!strcmp (tok, "reusable"))
    res = lglreusable (lgl, intarg ("reusable"));
  else if (noarg (tok, "setphases")) lglsetphases (lgl);
  else if (!strcmp (tok, "setphase")) lglsetphase (lgl, intarg ("setphase"));
  else if (!strcmp (tok, "resetphase"))
    lglresetphase (lgl, intarg ("resetphase"));
  else if (!strcmp (tok, "option")) {
    if (!(opt = strtok (0, " "))) perr ("option name missing");
    lglsetopt (lgl, opt, intarg ("option"));
  } else if (noarg (tok, "release")) lglrelease (lgl);
  else perr ("invalid command '%s'", tok);
  lineno++;
  len = 0;
  goto NEXT;
DONE:
  if(close == 1) fclose (file);
  if(close == 2) pclose (file);
  msg ("done %s", name);
  return 0;
}
Example #2
0
static void
btor_lingeling_enable_verbosity (BtorSATMgr * smgr)
{
  BtorLGL * blgl = smgr->solver;
  lglsetopt (blgl->lgl, "verbose", 1);
}
Example #3
0
static int
btor_passdown_lingeling_options (BtorSATMgr * smgr,
				 const char * optstr,
				 LGL * external_lgl)
{
  char * str, * p, * next, * eq, * opt, * val;
  LGL * lgl = external_lgl ? external_lgl : 0;
  int len, valid, res = 1;

  assert (optstr);
  len = strlen (optstr);

  BTOR_NEWN (smgr->mm, str, len + 1);
  strcpy (str, optstr);

  res = 1;

  for (p = str; *p; p = next)
    {
      if (*p == ',')
	next = p + 1;
      else
	{
	  opt = p;
	  while (*p != ',' && *p)
	    p++;

	  if (*p)
	    {
	      assert (*p == ',');
	      *p = 0;
	      next = p + 1;
	    }
	  else next = p;

	  val = eq = 0;

	  if (!isalpha (*opt))
	    valid = 0;
	  else
	    {
	      for (p = opt + 1; isalnum (*p); p++)
		;

	      if (*p == '=')
		{
		  *(eq = p++) = 0;
		  val = p;
		  if (*p == '-') p++;
		  if (isdigit (*p))
		    {
		      while (isdigit (*p))
			p++;

		      valid = !*p;
		    }
		  else
		    valid = 0;
		}
	      else
		valid = 0;
	    }

	  if (valid)
	    {
	      if (!lgl)
		{
		  assert (!external_lgl);
		  lgl = lglinit ();
		}

	      if (lglhasopt (lgl, opt))
		{
		  if (external_lgl && val)
		    {
		      assert (lgl == external_lgl);
		      btor_msg_sat (smgr, 2,
			"setting Lingeling option --%s=%s", opt, val);
		      lglsetopt (lgl, opt, atoi (val));
		    }
		}
	      else
		valid = 0;
	    }

	  if (!valid) res = 0;
	  if (valid || external_lgl) continue;

	  if (eq) *eq = '=';
	  btor_msg_sat (smgr, 0,
	    "*** can not pass down to Lingeling invalid option '%s'", optstr);
	}
    }

  BTOR_DELETEN (smgr->mm, str, len + 1);
  if (lgl && !external_lgl) lglrelease (lgl);

  return res;
}
Example #4
0
static int
btor_lingeling_sat (BtorSATMgr * smgr, int limit)
{
  BtorLGL * blgl = smgr->solver;
  LGL * lgl = blgl->lgl, * bforked;
  const int clone = 1; // TODO?
  const char * str;
  int res, bfres;
  char name[80];

  if (!smgr->inc_required)
    {
      lglsetopt (lgl, "clim", -1);
      res = lglsat (lgl);
      return res;
    }

  lglsetopt (lgl, "flipping", 0);
  
  if (smgr->nofork || (0 <= limit && limit < blgl->blimit))
    {
      if (limit < INT_MAX) lglsetopt (lgl, "clim", limit);
      res = lglsat (lgl);
    }
  else
    {
      btor_msg_sat (smgr, 1, "blimit = %d", blgl->blimit);
      lglsetopt (lgl, "clim", blgl->blimit);
      // if (smgr->inc_required) lglsetopt (lgl, "plain", 1);
      if (!(res = lglsat (lgl)))
	{
	  lglsetopt (lgl, "plain", 0);
	  blgl->blimit *= 2;
	  if (blgl->blimit > BTOR_LGL_MAX_BLIMIT)
	    blgl->blimit = BTOR_LGL_MAX_BLIMIT;
	  blgl->nforked++;
	  if (clone) {
	    bforked = lglclone (lgl);
	    lglfixate (bforked);
	    lglmeltall (bforked);
	    str = "clone";
	  } else bforked = lglbrutefork (lgl, 0), str = "fork";
	  lglsetopt (bforked, "seed", blgl->nforked);
	  lglsetopt (bforked, "flipping", 1);
	  sprintf (name, "[lgl%s%d] ", str, blgl->nforked);
	  lglsetprefix (bforked, name);
	  lglsetout (bforked, smgr->output);
	  if (lglgetopt (lgl, "verbose")) lglsetopt (bforked, "verbose", 1);
	  lglsetopt (bforked, "clim", limit);
	  res = lglsat (bforked);
	  if (smgr->verbosity > 0) lglstats (bforked);
	  if (clone) {
	    bfres = lglunclone (lgl, bforked);
	    lglrelease (bforked);
	  } else bfres = lgljoin (lgl, bforked);
	  assert (!res || bfres == res);
	  res = bfres;
	}
      else
	{
	  blgl->blimit = 9*(blgl->blimit/10);
	  if (blgl->blimit < BTOR_LGL_MIN_BLIMIT)
	    blgl->blimit = BTOR_LGL_MIN_BLIMIT;
	}
    }
  return res;
}
Example #5
0
void
btor_process_skeleton (Btor * btor)
{
  BtorPtrHashTable * ids;
  BtorNodePtrStack unmark_stack;
  int count, fixed;
  BtorNodePtrStack work_stack;
  BtorMemMgr * mm = btor->mm;
  BtorHashTableIterator it;
  double start, delta;
  int res, lit, val;
  BtorNode * exp;
  LGL * lgl;

  start = btor_time_stamp ();

  ids = btor_new_ptr_hash_table (mm,
          (BtorHashPtr) btor_hash_exp_by_id,
          (BtorCmpPtr) btor_compare_exp_by_id);

  lgl = lglinit ();
  lglsetprefix (lgl, "[lglskel] ");

  if (btor->options.verbosity.val >= 2)
    {
      lglsetopt (lgl, "verbose", btor->options.verbosity.val - 1);
      lglbnr ("Lingeling", "[lglskel] ", stdout);
      fflush (stdout);
    }
  else
    lglsetopt (lgl, "verbose", -1);        

  count = 0;

  BTOR_INIT_STACK (work_stack);
  BTOR_INIT_STACK (unmark_stack);

  btor_init_node_hash_table_iterator (&it, btor->synthesized_constraints);
  btor_queue_node_hash_table_iterator (&it, btor->unsynthesized_constraints);
  while (btor_has_next_node_hash_table_iterator (&it))
    {
      count++;
      exp = btor_next_node_hash_table_iterator (&it);
      assert (btor_get_exp_width (btor, exp) == 1);
      process_skeleton_tseitin (btor, lgl,
        &work_stack, &unmark_stack, ids, exp);
      lgladd (lgl, process_skeleton_tseitin_lit (ids, exp));
      lgladd (lgl, 0);
    }

  BTOR_RELEASE_STACK (mm, work_stack);

  while (!BTOR_EMPTY_STACK (unmark_stack))
    {
      exp = BTOR_POP_STACK (unmark_stack);
      assert (!BTOR_IS_INVERTED_NODE (exp));
      assert (exp->mark);
      exp->mark = 0;
    }

  BTOR_RELEASE_STACK (mm, unmark_stack);

  BTOR_MSG (btor->msg, 1, "found %u skeleton literals in %d constraints",
                ids->count, count);

  res = lglsimp (lgl, 0);

  if (btor->options.verbosity.val)
    {
      BTOR_MSG (btor->msg, 1, "skeleton preprocessing result %d", res);
      lglstats (lgl);
    }

  fixed = 0;

  if (res == 20)
    {
      BTOR_MSG (btor->msg, 1, "skeleton inconsistent");
      btor->inconsistent = 1;
    }
  else
    {
      assert (res == 0 || res == 10);
      btor_init_node_hash_table_iterator (&it, ids);
      while (btor_has_next_node_hash_table_iterator (&it))
        {
          exp = btor_next_node_hash_table_iterator (&it);
          assert (!BTOR_IS_INVERTED_NODE (exp));
          lit = process_skeleton_tseitin_lit (ids, exp);
          val = lglfixed (lgl, lit);
          if (val)
            {
              if (!btor_find_in_ptr_hash_table (
                    btor->synthesized_constraints, exp) &&
                  !btor_find_in_ptr_hash_table (
                    btor->unsynthesized_constraints, exp))
                {
                  if (val < 0)
                    exp = BTOR_INVERT_NODE (exp);
                  btor_assert_exp (btor, exp);
                  btor->stats.skeleton_constraints++;
                  fixed++;
                }
            }
          else
            {
              assert (!btor_find_in_ptr_hash_table (
                         btor->synthesized_constraints, exp));
              assert (!btor_find_in_ptr_hash_table (
                         btor->unsynthesized_constraints, exp));
            }
        }
    }

  btor_delete_ptr_hash_table (ids);
  lglrelease (lgl);

  delta = btor_time_stamp () - start;
  btor->time.skel += delta;
  BTOR_MSG (btor->msg, 1,
      "skeleton preprocessing produced %d new constraints in %.1f seconds",
      fixed, delta);
  assert (btor_check_id_table_mark_unset_dbg (btor));
}