Ejemplo n.º 1
0
void Type::genTypeInfo(Scope *sc)
{
    //printf("Type::genTypeInfo() %p, %s\n", this, toChars());
    if (!Type::dtypeinfo)
    {
        error(Loc(), "TypeInfo not found. object.d may be incorrectly installed or corrupt, compile with -v switch");
        fatal();
    }

    Type *t = merge2(); // do this since not all Type's are merge'd
    if (!t->vtinfo)
    {
        if (t->isShared())      // does both 'shared' and 'shared const'
            t->vtinfo = TypeInfoSharedDeclaration::create(t);
        else if (t->isConst())
            t->vtinfo = TypeInfoConstDeclaration::create(t);
        else if (t->isImmutable())
            t->vtinfo = TypeInfoInvariantDeclaration::create(t);
        else if (t->isWild())
            t->vtinfo = TypeInfoWildDeclaration::create(t);
        else
            t->vtinfo = t->getTypeInfoDeclaration();
        assert(t->vtinfo);

        /* If this has a custom implementation in std/typeinfo, then
         * do not generate a COMDAT for it.
         */
        if (!t->builtinTypeInfo())
        {
            // Generate COMDAT
            if (sc)                     // if in semantic() pass
            {
                if (sc->func && !sc->func->isInstantiated() && sc->func->inNonRoot())
                {
                    // Bugzilla 13043: Avoid linking TypeInfo if it's not
                    // necessary for root module compilation
                }
                else
                {
                    // Find module that will go all the way to an object file
                    Module *m = sc->module->importedFrom;
                    m->members->push(t->vtinfo);

                    semanticTypeInfo(sc, t);
                }
            }
            else                        // if in obj generation pass
            {
                t->vtinfo->toObjFile(global.params.multiobj);
            }
        }
    }
    if (!vtinfo)
        vtinfo = t->vtinfo;     // Types aren't merged, but we can share the vtinfo's
    assert(vtinfo);
}
Ejemplo n.º 2
0
Expression *Type::getTypeInfo(Scope *sc)
{
    //printf("Type::getTypeInfo() %p, %s\n", this, toChars());
    if (!Type::typeinfo)
    {
        error(0, "TypeInfo not found. object.d may be incorrectly installed or corrupt, compile with -v switch");
        fatal();
    }

    Expression *e = 0;
    Type *t = merge2(); // do this since not all Type's are merge'd

    if (!t->vtinfo)
    {
#if DMDV2
        if (t->isShared())
            t->vtinfo = new TypeInfoSharedDeclaration(t);
        else if (t->isConst())
            t->vtinfo = new TypeInfoConstDeclaration(t);
        else if (t->isImmutable())
            t->vtinfo = new TypeInfoInvariantDeclaration(t);
        else if (t->isWild())
            t->vtinfo = new TypeInfoWildDeclaration(t);
        else
#endif
            t->vtinfo = t->getTypeInfoDeclaration();
        assert(t->vtinfo);

        /* If this has a custom implementation in std/typeinfo, then
         * do not generate a COMDAT for it.
         */
        if (!t->builtinTypeInfo())
        {   // Generate COMDAT
            if (sc)         // if in semantic() pass
            {   // Find module that will go all the way to an object file
                Module *m = sc->module->importedFrom;
                m->members->push(t->vtinfo);
            }
            else            // if in obj generation pass
            {
#if IN_DMD
                t->vtinfo->toObjFile(0); // TODO: multiobj
#else
                t->vtinfo->codegen(sir);
#endif
            }
        }
    }
    e = new VarExp(0, t->vtinfo);
    e = e->addressOf(sc);
    e->type = t->vtinfo->type;      // do this so we don't get redundant dereference
    return e;
}
Ejemplo n.º 3
0
int sort2(int *numbers,int left, int right)
{
  int mid;
  int inv=0;
  if (right > left)
  {
    mid = (right + left) / 2;
    inv+=sort2(numbers,left, mid);
    inv+=sort2(numbers,mid+1, right);
 
    inv+=merge2(numbers,left, mid+1, right);
  }
return inv;
}
Ejemplo n.º 4
0
void Damage::Merge (BoxObj& newb) {
    BoxObj* a1, *a2;
    int newArea, area1, area2, diff1, diff2, diff3, maximum;
    Iterator i;

    FirstArea(i);
    a1 = GetArea(i);
    Next(i);
    a2 = GetArea(i);
    BoxObj merge1(*a1 + newb);
    BoxObj merge2(*a2 + newb);
    BoxObj merge3(*a1 + *a2);

    newArea = Area(newb);
    area1 = Area(*a1);
    area2 = Area(*a2);
    diff1 = area1 + newArea - Area(merge1);
    diff2 = area2 + newArea - Area(merge2);
    diff3 = area1 + area2 - Area(merge3);
    maximum = max(max(diff1, diff2), diff3);

    if (maximum == diff1) {
	if (a2->Intersects(merge1)) {
	    *a1 = merge1 + *a2;
            DeleteArea(a2);
	} else {
	    *a1 = merge1;
	}

    } else if (maximum == diff2) {
	if (a1->Intersects(merge2)) {
	    *a2 = merge2 + *a1;
            DeleteArea(a1);
	} else {
	    *a2 = merge2;
	}

    } else {
	if (newb.Intersects(merge3)) {
	    *a1 = merge3 + newb;
            DeleteArea(a2);
	} else {
	    *a1 = merge3;
	    *a2 = newb;
	}
    }
}
Ejemplo n.º 5
0
ListNode* merge(vector<ListNode*> &lists) {
    int size = lists.size();
    if(size==0)
        return NULL;
    queue<ListNode*> q;
    for(int i=0; i<size; i++)
        q.push(lists[i]);
    
    while(q.size()>1){
        ListNode *n1 = q.front();
        q.pop();
        ListNode *n2 = q.front();
        q.pop();
        q.push(merge2(n1,n2));
    }
    return q.front();
}
int main()
{
    {
        int a[6] = {1,3,4,6,8,9};
        int b[12] = {0,2,5,7,10,11};
        merge1(a, b, 6);
        for(int i = 0;i < 12;++i)
            std::cout<<b[i]<<",";
        std::cout<<"\n";
    }
    std::cout<<"---\n";
    {
        int a[6] = {1,3,4,6,8,9};
        int b[12] = {0,2,5,7,10,11};
        merge2(a, b, 6);
        for(int i = 0;i < 12;++i)
            std::cout<<b[i]<<",";
        std::cout<<"\n";
    }
}
Ejemplo n.º 7
0
Expression *Type::getTypeInfo(Scope *sc)
{
    //printf("Type::getTypeInfo() %p, %s\n", this, toChars());
    if (!Type::dtypeinfo)
    {
        error(Loc(), "TypeInfo not found. object.d may be incorrectly installed or corrupt, compile with -v switch");
        fatal();
    }

    Type *t = merge2(); // do this since not all Type's are merge'd
    if (!t->vtinfo)
    {
#if DMDV2
        if (t->isShared())      // does both 'shared' and 'shared const'
            t->vtinfo = new TypeInfoSharedDeclaration(t);
        else if (t->isConst())
            t->vtinfo = new TypeInfoConstDeclaration(t);
        else if (t->isImmutable())
            t->vtinfo = new TypeInfoInvariantDeclaration(t);
        else if (t->isWild())
            t->vtinfo = new TypeInfoWildDeclaration(t);
        else
#endif
            t->vtinfo = t->getTypeInfoDeclaration();
        assert(t->vtinfo);
        vtinfo = t->vtinfo;

        /* If this has a custom implementation in std/typeinfo, then
         * do not generate a COMDAT for it.
         */
        if (!t->builtinTypeInfo())
        {
            // Generate COMDAT
            if (sc)                     // if in semantic() pass
            {
                // Find module that will go all the way to an object file
                Module *m = sc->module->importedFrom;
                m->members->push(t->vtinfo);

                if (ty == Tstruct)
                {
                    Dsymbol *s;
                    StructDeclaration *sd = ((TypeStruct *)this)->sym;
                    if ((sd->xeq  && sd->xeq  != sd->xerreq  ||
                         sd->xcmp && sd->xcmp != sd->xerrcmp ||
                         search_toHash(sd) ||
                         search_toString(sd)
                        ) && inNonRoot(sd))
                    {
                        //printf("deferred sem3 for TypeInfo - sd = %s, inNonRoot = %d\n", sd->toChars(), inNonRoot(sd));
                        Module::addDeferredSemantic3(sd);
                    }
                }
            }
            else                        // if in obj generation pass
            {
                t->vtinfo->toObjFile(global.params.multiobj);
            }
        }
    }
    if (!vtinfo)
        vtinfo = t->vtinfo;     // Types aren't merged, but we can share the vtinfo's
    Expression *e = new VarExp(Loc(), t->vtinfo);
    e = e->addressOf(sc);
    e->type = t->vtinfo->type;          // do this so we don't get redundant dereference
    return e;
}
Ejemplo n.º 8
0
Archivo: typinf.c Proyecto: rainers/dmd
TypeInfoDeclaration *Type::buildTypeInfo(Scope *sc, bool checkNeedSemantic)
{
    if (vtinfo)
        return vtinfo;
    if (sc && checkNeedSemantic && !typeInfoNeedsSemantic())
        return 0;

    //printf("Type::getTypeInfo() %p, %s\n", this, toChars());
    if (!Type::dtypeinfo)
    {
        error(Loc(), "TypeInfo not found. object.d may be incorrectly installed or corrupt, compile with -v switch");
        fatal();
    }

    Type *t = merge2(); // do this since not all Type's are merge'd
    if (!t->vtinfo)
    {
        if (t->isShared())      // does both 'shared' and 'shared const'
            t->vtinfo = new TypeInfoSharedDeclaration(t);
        else if (t->isConst())
            t->vtinfo = new TypeInfoConstDeclaration(t);
        else if (t->isImmutable())
            t->vtinfo = new TypeInfoInvariantDeclaration(t);
        else if (t->isWild())
            t->vtinfo = new TypeInfoWildDeclaration(t);
        else
            t->vtinfo = t->getTypeInfoDeclaration();
        assert(t->vtinfo);
        vtinfo = t->vtinfo;

        /* If this has a custom implementation in std/typeinfo, then
         * do not generate a COMDAT for it.
         */
        if (t->ty == Terror)
            vtinfo->errors = 1;
        else if (!t->builtinTypeInfo())
        {
            // Generate COMDAT
            if (sc)                     // if in semantic() pass
            {
                // Find module that will go all the way to an object file
                Module *m = sc->module->importedFrom;
                m->members->push(t->vtinfo);
                if(m->semanticRun >= 3)
                {
                    Module::addDeferredSemantic3(t->vtinfo);
                    t->vtinfo->deferredScope = sc;
                    sc->setNoFree();
                }
                if (ty == Tstruct)
                {
                    Dsymbol *s;
                    StructDeclaration *sd = ((TypeStruct *)this)->sym;
                    if (sd->members &&
                        (sd->xeq  && sd->xeq  != sd->xerreq  ||
                         sd->xcmp && sd->xcmp != sd->xerrcmp ||
                         search_toHash(sd) ||
                         search_toString(sd)
                        ) && inNonRoot(sd))
                    {
                        //printf("deferred sem3 for TypeInfo - sd = %s, inNonRoot = %d\n", sd->toChars(), inNonRoot(sd));
                        Module::addDeferredSemantic3(sd);
                    }
                }
            }
            else                        // if in obj generation pass
            {
                // it is always a problem if this is called from the backend without
                //  being added to the AST for semantic analysis (no RTInfo generated)
                // to ease transition, modifier types are just put out as they just forward
                //  to the actual TypeInfo
                if (t->typeInfoNeedsSemantic())
                    error(Loc(), "ICE: unexpected type info request for %s", t->toChars());
                t->vtinfo->toObjFile(global.params.multiobj);
            }
        }
    }
    if (!vtinfo)
        vtinfo = t->vtinfo;     // Types aren't merged, but we can share the vtinfo's
    return vtinfo;
}
Ejemplo n.º 9
0
int main(int argc, char **argv)
{
    FILE *fp, *tp, *sp;
    Widget widgets[MAXW];
    char key[16], *runpath, *wishpath, *scriptpath, *tkpath, *cp;
    char *scratchpath = "scratchrun.tk";
    char cmd[256];
    int i,nw,noexec;

    fprintf(stderr,"%s\n",VERSION);

    if (argc == 1) {
      usage();
    } else {
        runpath = NULL;
        scriptpath = NULL;
        tkpath = NULL;
        wishpath = "wish";
        noexec=0;
    	for (i=1; i<argc; i++) {
    	    cp = argv[i];
    	    if (*cp != '-')
    	        scriptpath = (char *) strdup(cp);
    	    else {
    	        cp++;
    	        switch (*cp) {
    	        case 'r':
                    runpath = (char *) strdup(argv[++i]);
    	            break;
    	        case 'w':
                    wishpath = (char *) strdup(argv[++i]);
    	            break;
    	        case 't':
    	            tkpath = (char *) strdup(argv[++i]);
    	            break;
                case 'x':
                    noexec = 1;
                    break;
                case 'e':
                    example();      /* will exit the program */
                    break;
                case 'h':
		    usage();
                    break;
    	        default:
    	            fprintf(stderr,"Option -%s not supported yet\n",cp);
		    usage();
    	            break;
    	        }
    	    }
    	}
    }
    if (runpath == NULL) runpath = scriptpath;
    if (tkpath == NULL) {
        tkpath = (char *) malloc(strlen(scriptpath)+4);
        sprintf(tkpath,"%s.tk",scriptpath);
    }

    if (strcmp(scriptpath,tkpath)==0) {
        fprintf(stderr,"Error: Run and Script are the same (%s)\n",runpath);
        exit(1);
    }

    fp = fopen(scriptpath,"r");
    if (fp == NULL) {
        fprintf(stderr,"Error: ScriptFile %s could not be opened\n",scriptpath);
        exit(1);
    }

    tp = fopen(tkpath,"w");
    if (tp == NULL) {
        fprintf(stderr,"Error: TkFile %s could not be written\n",tkpath);
        exit(1);
    }

    sp = fopen(scratchpath,"w");
    if (sp == NULL) {
        fprintf(stderr,"Error: ScratchFile %s could not be written\n",scratchpath);
        exit(1);
    }
    
    
    fprintf(tp,preamble,VERSION);
    nw = parse(fp, tp, sp, MAXW, widgets);
    fclose(fp);
    fclose(sp);


    fprintf(tp,"set keyList {");
    for (i=0; i<nw; i++) {
        if (widgets[i].list)
            fprintf(tp," .keys.%s.frame.val",widgets[i].key);
    }
    fprintf(tp," }\n");


    fprintf(tp,"proc my_save {} {\n");
    fprintf(tp,"  puts \"my_save:\"\n");
    fprintf(tp,"  set filename \"%s.key\"\n",runpath);
    fprintf(tp,"  set file [open $filename w]\n");
    for (i=0; i<nw; i++) {
      sprintf(key,widgets[i].key);
      fprintf(tp,"  global var_%s\n",key);
      fprintf(tp,"  puts $file \"%s=$var_%s\"\n",key,key);
    }
    fprintf(tp,"  close $file\n");
    fprintf(tp,"}\n");

    fprintf(tp,"proc my_load {} {\n");
    fprintf(tp,"  puts \"my_load:\"\n");
    for (i=0; i<nw; i++) {
      sprintf(key,widgets[i].key);
      fprintf(tp,"  global var_%s\n",key);
    }
    fprintf(tp,"  set filename \"%s.key\"\n",runpath);
    fprintf(tp,"  set file [open $filename r]\n");
    fprintf(tp,"  while {[gets $file line] >= 0} {\n");
    fprintf(tp,"    set key [lindex [split $line =] 0]\n");
    fprintf(tp,"    set val [lindex [split $line =] 1]\n");
    for (i=0; i<nw; i++) {
      sprintf(key,widgets[i].key);
      if (widgets[i].type == W_CHECK)
	fprintf(tp,"    if {$key == \"%s\"} { set var_%s $val; load_var_%s }\n",key,key,key);
      else
	fprintf(tp,"    if {$key == \"%s\"} { set var_%s $val }\n",key,key);
    }
    fprintf(tp,"  }\n");
    fprintf(tp,"  close $file\n");
    fprintf(tp,"}\n");


    fprintf(tp,"proc my_run {} {\n");
    fprintf(tp,"  puts \"my_run:\"\n");
    for (i=0; i<nw; i++) {
    	sprintf(key,widgets[i].key);
        fprintf(tp,"  global var_%s\n",key);
        fprintf(tp,"  lappend args \"%s=$var_%s\"\n",key,key);
    }
    fprintf(tp,"   eval exec <@stdin >@stdout %s $args\n",runpath);
    fprintf(tp,"}\n");

    

    sp = fopen(scratchpath,"r");
    if (sp == NULL) {
        fprintf(stderr,"Error: ScratchFile %s could not be read\n",scratchpath);
        exit(1);
    }
    (void) merge2(tp, sp);

    fprintf(tp,"%s",postamble);

    fprintf(tp,"# Found %d widgets\n",nw);
    for (i=0; i<nw; i++) {
        fprintf(tp,"# %d: %s=%s\n",widgets[i].type,
                widgets[i].key, widgets[i].val);
    }
    
    
    fclose(tp);

    if (noexec) exit(0);

    sprintf(cmd,"%s -f %s",wishpath,tkpath);
    fprintf(stderr,"Running %s\n",cmd);
    system(cmd);
    return 0;
}
Ejemplo n.º 10
0
void bspParSort(){

  int Log2(int x);
  void mergeSort(int x, int *temp1);
  void merge2(int *arr1, int *arr2, int size);

  int *localArr; /* local array in each processor */
  int i,j,k; /* index variables */
  int n_divide_p; /* Avoid multiple computation */
  int n; /* Number of elements to be sorted */
  int szLocalArray; /* Size of local array */
  double time0, time1; /* Time */
  FILE *ifp = 0; /* Reader to read sequence of numbers to be sorted */

  bsp_begin(P);
  int p= bsp_nprocs(); /* Number of processors obtained */ 
  int s= bsp_pid();    /* Processor number */ 

  //Get number of elements to be sorted
  if(s==0){
    ifp = fopen("sort","r");
    if(ifp == NULL){
      fprintf(stderr, "Can't open input file!\n");
      exit(1);
    }
    fscanf(ifp, "%i", &n);
  }

  // Make sure every processor knows everything
  bsp_push_reg(&n,sizeof(int));
  bsp_sync();
  bsp_get(0,&n,0,&n,sizeof(int));
  bsp_sync();
  bsp_pop_reg(&n);

  //Setup distribution 
  n_divide_p = n/p;
  szLocalArray = n/pow(2,ceil(Log2(s+1)));
  localArr = vecalloci(szLocalArray);
  bsp_push_reg(localArr,sizeof(int)*szLocalArray);

  if(s==0){ 
    printf("Distribution start\n"); fflush(stdout); 
  }

  bsp_sync();
  int value;
  if(s==0){
    //allocate to array on proc 0
    for(i=0; i< n_divide_p; i++){
      fscanf(ifp, "%i", &value);
      localArr[i]=value;      
    }
    //Send to arrays on other processors
    for(i=1; i< p; i++){
      for(j=0;j<n_divide_p;j++){
        fscanf(ifp, "%i", &value);
        bsp_put(i,&value,localArr,j*sizeof(int),sizeof(int));
      }
    }
    fclose(ifp);
  }
  bsp_sync();
  if(s==0){ 
    printf("Distribution done\n"); fflush(stdout); 
  }

  //Distribution done and we can start time measurement 
  if(s==0){
    printf("Time start\n"); fflush(stdout);
  }
  time0 = bsp_time();

  //Locally sort each array
  if(s==0){
    printf("Local sort\n"); fflush(stdout);
  }
  mergeSort(n_divide_p, localArr);
  bsp_sync();

  //Merging 
  int *temp = malloc(sizeof(int)*pow(2,Log2(p))*n_divide_p);
  for(j=1;j<Log2(p)+1;j++){
    if(s<p/pow(2,j)){
      for(k=0;k<pow(2,j-1)*n_divide_p;k++){
        bsp_get(s+(p/pow(2,j)),localArr,k*sizeof(int),&(temp[k]),sizeof(int));
      }
    }
    bsp_sync();

    if(s<p/pow(2,j)){
      merge2(localArr, temp, n_divide_p*pow(2,j-1));
    }

    bsp_sync();
    if(s==0){ 
      printf("Round %i out of %i rounds of merging done (on proc 0)\n",j,Log2(p)); fflush(stdout); 
    }
  }
  if(s==0){
    printf("Sorting done\n"); fflush(stdout);
  }
  bsp_sync();
 
  //Print sorted array - expensive if sample is big
  /*
  if(s==0){
    printf("Sorted sequence is:\n");
    for(i=0; i<szLocalArray; i++){
      printf("%i ",localArr[i]); fflush(stdout);
    }
    printf("\n"); fflush(stdout);
  }
  */

  //Parallel algorithm ends
  time1 = bsp_time();
  if(s==0){
    printf("Time stop\n"); fflush(stdout);
  }

  //Report time to user
  if(s==0){
    printf("Sorting took %.6lf seconds.\n", time1-time0); fflush(stdout);
  }
  
  //Clean up
  free(temp);
  bsp_pop_reg(localArr); free(localArr);

  bsp_end();
} /* End bspParSort */