kChinese.h File Reference

#include "misc/auxiliary.h"
#include "misc/intvec.h"
#include "polys/monomials/p_polys.h"
#include "polys/matpol.h"
#include "polys/simpleideals.h"
#include <gmp.h>

Go to the source code of this file.

Functions
poly	p_ChineseRemainder (poly *xx, mpz_ptr *x, mpz_ptr *q, int rl, mpz_ptr *C, const ring R)
ideal	id_ChineseRemainder_0 (ideal *xx, number *q, int rl, const ring r)
ideal	id_Farey_0 (ideal xx, number N, const ring r)

Function Documentation

id_ChineseRemainder_0()

ideal id_ChineseRemainder_0	(	ideal *	xx,
		number *	q,
		int	rl,
		const ring	r
	)

Definition at line 199 of file kChinese.cc.

{
  int cpus = (long) feOptValue(FE_OPT_CPUS);
  if (cpus<1)
  {
    WerrorS("no sub-processes allowed");
    return NULL;
  }
  int cnt=0;int rw=0; int cl=0;
  // find max. size of xx[.]:
  for(int j=rl-1;j>=0;j--)
  {
    int i=IDELEMS(xx[j])*xx[j]->nrows;
    if (i>cnt) cnt=i;
    if (xx[j]->nrows >rw) rw=xx[j]->nrows; // for lifting matrices
    if (xx[j]->ncols >cl) cl=xx[j]->ncols; // for lifting matrices
  }
  if (rw*cl !=cnt)
  {
    WerrorS("format mismatch in CRT");
    return NULL;
  }
  if (cpus>=vspace::internals::MAX_PROCESS)
    cpus=vspace::internals::MAX_PROCESS-1;
  /* start no more than MAX_PROCESS-1 children */
  cpus=si_min(cpus,cnt/5);
  if (cpus<=1)
    /* at least 5 polys for each process, or switch to seriell version */
    return id_ChineseRemainder(xx,q,rl,r);
  ideal result=idInit(cnt,xx[0]->rank);
  result->nrows=rw; // for lifting matrices
  result->ncols=cl; // for lifting matrices
  int parent_pid=getpid();
  using namespace vspace;
  vmem_init();
  // Create a queue of int
  VRef<Queue<int> > queue = vnew<Queue<int> >();
  for(int i=cnt-1;i>=0; i--)
  {
    queue->enqueue(i); // the tasks: construct poly p[i]
  }
  for(int i=cpus;i>=0;i--)
  {
    queue->enqueue(-1); // stop sign, one for each child
  }
  // Create a queue of polys
  VRef<Queue<VRef<VString> > > rqueue = vnew<Queue<VRef<VString> > >();
  int *pids=(int*)omAlloc0(cpus*sizeof(int));
  for (int i=0;i<cpus;i++)
  {
    int pid = fork_process();
    if (pid==0) break; //child
    pids[i]=pid;
  }
  if (parent_pid!=getpid()) // child ------------------------------------------
  {
    si_set_signal(SIGTERM,sig_term_hdl_child);
    singular_close_links();
    feSetOptValue(FE_OPT_CPUS,0);
    number *x=(number *)omAlloc(rl*sizeof(number));
    poly *p=(poly *)omAlloc(rl*sizeof(poly));
    CFArray inv_cache(rl);
    EXTERN_VAR int n_SwitchChinRem;
    n_SwitchChinRem=1;
    loop
    {
      int ind=queue->dequeue();
      if (ind== -1)
      {
        _exit(0);
      }
 
      for(int j=rl-1;j>=0;j--)
      {
        if(ind>=IDELEMS(xx[j])*xx[j]->nrows) // out of range of this ideal
          p[j]=NULL;
        else
          p[j]=xx[j]->m[ind];
      }
      poly res=p_ChineseRemainder(p,x,q,rl,inv_cache,r);
      long l=size_poly(res,r);
      //printf("size: %ld kB\n",(l+1023)/1024);
      VRef<VString> msg = vstring(l+1);
      char *s=(char*)msg->str();
      send_poly(s,ind,res,r);
      rqueue->enqueue(msg);
      if (TEST_OPT_PROT) printf(".");
    }
  }
  else // parent ---------------------------------------------------
  {
    if (TEST_OPT_PROT) printf("%d children created\n",cpus);
    VRef<VString> msg;
    while(cnt>0)
    {
      msg=rqueue->dequeue();
      char *s=(char*)msg->str();
      int ind;
      poly p=NULL;
      get_poly(s,ind,&p,r);
      //printf("got res[%d]\n",ind);
      result->m[ind]=p;
      msg.free();
      cnt--;
    }
    int i=cpus-1;
    int done=0;
    while(done!=cpus)
    {
      BOOLEAN all_done=TRUE;
      if (pids[i]>0)
      {
        int p=si_waitpid(pids[i],NULL,WNOHANG);
        if (p>0)
        {
          pids[i]=0;
          done++;
        }
      }
      if (i==0) i=cpus;
      i--;
    }
    omFreeSize(pids,cpus*sizeof(int));
    // removes queues
    queue.free();
    rqueue.free();
    vmem_deinit();
  }
  return result;
}

id_Farey_0()

ideal id_Farey_0	(	ideal	xx,
		number	N,
		const ring	r
	)

Definition at line 330 of file kChinese.cc.

{
  int cnt=IDELEMS(x)*x->nrows;
  int cpus=(int)(long)feOptValue(FE_OPT_CPUS);
  if (cpus>=vspace::internals::MAX_PROCESS)
    cpus=vspace::internals::MAX_PROCESS-1;
  /* start no more than MAX_PROCESS-1 children */
  cpus=si_min(cpus,cnt/5);
  if (cpus<=1) /* at least 5 polys for each process,
                     or switch to seriell version */
    return id_Farey(x,N,r);
  ideal result=idInit(cnt,x->rank);
  result->nrows=x->nrows; // for lifting matrices
  result->ncols=x->ncols; // for lifting matrices
 
  int parent_pid=getpid();
  using namespace vspace;
  vmem_init();
  // Create a queue of int
  VRef<Queue<int> > queue = vnew<Queue<int> >();
  for(int i=cnt-1;i>=0; i--)
  {
    queue->enqueue(i); // the tasks: construct poly p[i]
  }
  for(int i=cpus;i>=0;i--)
  {
    queue->enqueue(-1); // stop sign, one for each child
  }
  // Create a queue of polys
  VRef<Queue<VRef<VString> > > rqueue = vnew<Queue<VRef<VString> > >();
  int *pids=(int*)omAlloc0(cpus*sizeof(int));
  for (int i=0;i<cpus;i++)
  {
    int pid = fork_process();
    if (pid==0) break; //child
    pids[i]=pid;
  }
  if (parent_pid!=getpid()) // child ------------------------------------------
  {
    si_set_signal(SIGTERM,sig_term_hdl_child);
    singular_close_links();
    feSetOptValue(FE_OPT_CPUS,0);
    loop
    {
      int ind=queue->dequeue();
      if (ind== -1)
      {
        _exit(0);
      }
 
      poly res=p_Farey(x->m[ind],N,r);
      long l=size_poly(res,r);
      VRef<VString> msg = vstring(l+1);
      char *s=(char*)msg->str();
      send_poly(s,ind,res,r);
      rqueue->enqueue(msg);
      if (TEST_OPT_PROT) printf(".");
    }
  }
  else // parent ---------------------------------------------------
  {
    if (TEST_OPT_PROT) printf("%d children created\n",cpus);
    VRef<VString> msg;
    while(cnt>0)
    {
      msg=rqueue->dequeue();
      char *s=(char*)msg->str();
      int ind;
      poly p=NULL;
      get_poly(s,ind,&p,r);
      //printf("got res[%d]\n",ind);
      result->m[ind]=p;
      msg.free();
      cnt--;
    }
    int i=cpus-1;
    int done=0;
    while(done!=cpus)
    {
      BOOLEAN all_done=TRUE;
      if (pids[i]>0)
      {
        int p=si_waitpid(pids[i],NULL,WNOHANG);
        if (p>0)
        {
          pids[i]=0;
          done++;
        }
      }
      if (i==0) i=cpus;
      i--;
    }
    omFreeSize(pids,cpus*sizeof(int));
    // removes queues
    queue.free();
    rqueue.free();
    vmem_deinit();
  }
  return result;
}

p_ChineseRemainder()

poly p_ChineseRemainder	(	poly *	xx,
		mpz_ptr *	x,
		mpz_ptr *	q,
		int	rl,
		mpz_ptr *	C,
		const ring	R
	)