void target_init(void) { paddr_t buf_vaddr; void *hdr_addr; /* TODO: Move into zynq_common once the init order is sorted out with gem_init needing * pktbufs, and app init running after target_init */ if (vmm_alloc_contiguous(vmm_get_kernel_aspace(), "pktbuf_headers", ZYNQ_PKTBUF_CNT * sizeof(pktbuf_buf_t), (void **)&hdr_addr, 0, 0, ARCH_MMU_FLAG_CACHED) < 0) { printf("Failed to initialize pktbuf hdr slab\n"); return; } for (size_t i = 0; i < ZYNQ_PKTBUF_CNT; i++) { pktbuf_create((void *)hdr_addr, sizeof(pktbuf_t)); hdr_addr += sizeof(pktbuf_t); } if (vmm_alloc_contiguous(vmm_get_kernel_aspace(), "pktbuf_buffers", ZYNQ_PKTBUF_CNT * sizeof(pktbuf_buf_t), (void **)&buf_vaddr, 0, 0, ARCH_MMU_FLAG_UNCACHED) < 0) { printf("Failed to initialize pktbuf vm slab\n"); return; } pktbuf_create_bufs((void *)buf_vaddr, ZYNQ_PKTBUF_CNT * sizeof(pktbuf_buf_t)); gem_init(GEM0_BASE); register_gpio_int_handler(ZYBO_BTN5, toggle_ledy, NULL); zynq_unmask_gpio_interrupt(ZYBO_BTN5); }
void target_init(void) { gem_init(GEM0_BASE); register_gpio_int_handler(ZYBO_BTN5, toggle_ledy, NULL); zynq_unmask_gpio_interrupt(ZYBO_BTN5); }
main() { int i; init_screens (); /* Initialisiation du 2Šme ‚cran */ gem_init(); /* Se trouve dans fichier Include GEM_INEX.C */ v_hide_c (handle); /* D‚sactiver pointeur souris */ for (i=20; i<=300; i++) { Cconws ("\33E"); /* Effacer ‚cran */ v_gtext (handle, i, i, "Salut!"); /* Affichage texte sous GEM */ swap_screens (); /* Commuter ‚crans log./phys. */ Vsync(); /* Attente retour image */ } Crawcin(); /* Attente appui touche */ Setscreen (screen1, screen1, -1); /* Retour … l'‚cran normal */ v_show_c (handle, 1); /* Pointeur souris actif */ gem_exit(); }
void platform_init(void) { uart_init(); /* enable if we want to see some hardware boot status */ #if 0 printf("zynq boot status:\n"); printf("\tREBOOT_STATUS 0x%x\n", SLCR_REG(REBOOT_STATUS)); printf("\tBOOT_MODE 0x%x\n", SLCR_REG(BOOT_MODE)); zynq_dump_clocks(); #endif gem_init(GEM0_BASE, 256*1024); }
main() { gem_init(); whandle = wind_create (4095, 20, 20, 280, 150); /* 4095 = tous les organes de commande */ if (whandle < 0) form_alert (1, "[3][D‚sol‚!|Il ne reste plus de handle fenˆtre libre!][OK]" ); else { wind_open (whandle, 20, 20, 280, 150); /* Calcul de la zone de travail */ wind_calc (1, 4095, 20, 20, 280, 150, &x, &y, &w, &h); /* Conversion de hauteur/largeur du deuxiŠme angle (x2/y2) */ pxyarray[0] = x; pxyarray[1] = y; pxyarray[2] = x+w-1; pxyarray[3] = y+h-1; /* Effacer la zone de travail */ vsf_interior (handle, 0); /* Remplir avec couleur du fond */ vsf_perimeter (handle, 0); /* Pas de cadre */ v_bar (handle, pxyarray); vsf_perimeter (handle, 1); /* R‚activer le cadre */ Crawcin(); /* Attendre appui touche */ wind_close (whandle); wind_delete (whandle); } gem_exit(); }
main() { gem_init(); v_gtext (handle, 0, 14, "Tapez une touche. Si vous n'avez pas tap‚ de touche dans"); v_gtext (handle, 0, 30, "3 secondes, le programme "); v_gtext (handle, 0, 46, "s'arrˆtera."); which = evnt_multi (33, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0L, 3000, 0, &dummy, &dummy, &dummy, &dummy, &touche, &dummy); if (which == 1) v_gtext (handle, 0, 80, "Taper une touche pour quitter"); else v_gtext (handle, 0, 80, "Arrˆt dans 3 secondes"); Crawcin(); /* Attendre touche */ gem_exit(); }
void platform_init(void) { uart_init(); /* enable if we want to see some hardware boot status */ #if 0 printf("zynq boot status:\n"); printf("\tREBOOT_STATUS 0x%x\n", SLCR_REG(REBOOT_STATUS)); printf("\tBOOT_MODE 0x%x\n", SLCR_REG(BOOT_MODE)); zynq_dump_clocks(); printf("zynq mio:\n"); for (size_t i = 0; i < 54; i++) { printf("\t%02u: 0x%08x", i, *REG32((uintptr_t)&SLCR->MIO_PIN_00 + (i * 4))); if (i % 4 == 3 || i == 53) { putchar('\n'); } } #endif gem_init(GEM0_BASE, 256*1024); }
static void zynq_init(MachineState *machine) { ram_addr_t ram_size = machine->ram_size; const char *cpu_model = machine->cpu_model; const char *kernel_filename = machine->kernel_filename; const char *kernel_cmdline = machine->kernel_cmdline; const char *initrd_filename = machine->initrd_filename; ObjectClass *cpu_oc; ARMCPU *cpu; MemoryRegion *address_space_mem = get_system_memory(); MemoryRegion *ext_ram = g_new(MemoryRegion, 1); MemoryRegion *ocm_ram = g_new(MemoryRegion, 1); DeviceState *dev; SysBusDevice *busdev; qemu_irq pic[64]; Error *err = NULL; int n; if (!cpu_model) { cpu_model = "cortex-a9"; } cpu_oc = cpu_class_by_name(TYPE_ARM_CPU, cpu_model); cpu = ARM_CPU(object_new(object_class_get_name(cpu_oc))); /* By default A9 CPUs have EL3 enabled. This board does not * currently support EL3 so the CPU EL3 property is disabled before * realization. */ if (object_property_find(OBJECT(cpu), "has_el3", NULL)) { object_property_set_bool(OBJECT(cpu), false, "has_el3", &err); if (err) { error_report_err(err); exit(1); } } object_property_set_int(OBJECT(cpu), ZYNQ_BOARD_MIDR, "midr", &err); if (err) { error_report_err(err); exit(1); } object_property_set_int(OBJECT(cpu), MPCORE_PERIPHBASE, "reset-cbar", &err); if (err) { error_report_err(err); exit(1); } object_property_set_bool(OBJECT(cpu), true, "realized", &err); if (err) { error_report_err(err); exit(1); } /* max 2GB ram */ if (ram_size > 0x80000000) { ram_size = 0x80000000; } /* DDR remapped to address zero. */ memory_region_allocate_system_memory(ext_ram, NULL, "zynq.ext_ram", ram_size); memory_region_add_subregion(address_space_mem, 0, ext_ram); /* 256K of on-chip memory */ memory_region_init_ram(ocm_ram, NULL, "zynq.ocm_ram", 256 << 10, &error_fatal); vmstate_register_ram_global(ocm_ram); memory_region_add_subregion(address_space_mem, 0xFFFC0000, ocm_ram); DriveInfo *dinfo = drive_get(IF_PFLASH, 0, 0); /* AMD */ pflash_cfi02_register(0xe2000000, NULL, "zynq.pflash", FLASH_SIZE, dinfo ? blk_by_legacy_dinfo(dinfo) : NULL, FLASH_SECTOR_SIZE, FLASH_SIZE/FLASH_SECTOR_SIZE, 1, 1, 0x0066, 0x0022, 0x0000, 0x0000, 0x0555, 0x2aa, 0); dev = qdev_create(NULL, "xilinx,zynq_slcr"); qdev_init_nofail(dev); sysbus_mmio_map(SYS_BUS_DEVICE(dev), 0, 0xF8000000); dev = qdev_create(NULL, "a9mpcore_priv"); qdev_prop_set_uint32(dev, "num-cpu", 1); qdev_init_nofail(dev); busdev = SYS_BUS_DEVICE(dev); sysbus_mmio_map(busdev, 0, MPCORE_PERIPHBASE); sysbus_connect_irq(busdev, 0, qdev_get_gpio_in(DEVICE(cpu), ARM_CPU_IRQ)); for (n = 0; n < 64; n++) { pic[n] = qdev_get_gpio_in(dev, n); } zynq_init_spi_flashes(0xE0006000, pic[58-IRQ_OFFSET], false); zynq_init_spi_flashes(0xE0007000, pic[81-IRQ_OFFSET], false); zynq_init_spi_flashes(0xE000D000, pic[51-IRQ_OFFSET], true); sysbus_create_simple("xlnx,ps7-usb", 0xE0002000, pic[53-IRQ_OFFSET]); sysbus_create_simple("xlnx,ps7-usb", 0xE0003000, pic[76-IRQ_OFFSET]); sysbus_create_simple("cadence_uart", 0xE0000000, pic[59-IRQ_OFFSET]); sysbus_create_simple("cadence_uart", 0xE0001000, pic[82-IRQ_OFFSET]); sysbus_create_varargs("cadence_ttc", 0xF8001000, pic[42-IRQ_OFFSET], pic[43-IRQ_OFFSET], pic[44-IRQ_OFFSET], NULL); sysbus_create_varargs("cadence_ttc", 0xF8002000, pic[69-IRQ_OFFSET], pic[70-IRQ_OFFSET], pic[71-IRQ_OFFSET], NULL); gem_init(&nd_table[0], 0xE000B000, pic[54-IRQ_OFFSET]); gem_init(&nd_table[1], 0xE000C000, pic[77-IRQ_OFFSET]); dev = qdev_create(NULL, "generic-sdhci"); qdev_init_nofail(dev); sysbus_mmio_map(SYS_BUS_DEVICE(dev), 0, 0xE0100000); sysbus_connect_irq(SYS_BUS_DEVICE(dev), 0, pic[56-IRQ_OFFSET]); dev = qdev_create(NULL, "generic-sdhci"); qdev_init_nofail(dev); sysbus_mmio_map(SYS_BUS_DEVICE(dev), 0, 0xE0101000); sysbus_connect_irq(SYS_BUS_DEVICE(dev), 0, pic[79-IRQ_OFFSET]); dev = qdev_create(NULL, "pl330"); qdev_prop_set_uint8(dev, "num_chnls", 8); qdev_prop_set_uint8(dev, "num_periph_req", 4); qdev_prop_set_uint8(dev, "num_events", 16); qdev_prop_set_uint8(dev, "data_width", 64); qdev_prop_set_uint8(dev, "wr_cap", 8); qdev_prop_set_uint8(dev, "wr_q_dep", 16); qdev_prop_set_uint8(dev, "rd_cap", 8); qdev_prop_set_uint8(dev, "rd_q_dep", 16); qdev_prop_set_uint16(dev, "data_buffer_dep", 256); qdev_init_nofail(dev); busdev = SYS_BUS_DEVICE(dev); sysbus_mmio_map(busdev, 0, 0xF8003000); sysbus_connect_irq(busdev, 0, pic[45-IRQ_OFFSET]); /* abort irq line */ for (n = 0; n < 8; ++n) { /* event irqs */ sysbus_connect_irq(busdev, n + 1, pic[dma_irqs[n] - IRQ_OFFSET]); } zynq_binfo.ram_size = ram_size; zynq_binfo.kernel_filename = kernel_filename; zynq_binfo.kernel_cmdline = kernel_cmdline; zynq_binfo.initrd_filename = initrd_filename; zynq_binfo.nb_cpus = 1; zynq_binfo.board_id = 0xd32; zynq_binfo.loader_start = 0; zynq_binfo.board_setup_addr = BOARD_SETUP_ADDR; zynq_binfo.write_board_setup = zynq_write_board_setup; arm_load_kernel(ARM_CPU(first_cpu), &zynq_binfo); }
void worker(int len, int lenc, int output_options, char* filename, char* filenamec, char* filenameA, int TC, int As, int GT, int Namps) { FILE* table=file_check(filename); // file is open to read if (table==NULL) exit(1); // if the file is not good we exit int i; gem* pool[len]; int pool_length[len]; pool[0]=malloc(2*sizeof(gem)); pool_length[0]=2; gem_init(pool[0] ,1,1.000000,1,0); // grade damage crit bbound gem_init(pool[0]+1,1,1.186168,0,1); // BB has more dmg int prevmax=pool_from_table(pool, pool_length, len, table); // killgem spec pool filling fclose(table); if (prevmax<len-1) { // if the killgems are not enough for (i=0;i<=prevmax;++i) free(pool[i]); // free if (prevmax>0) printf("Gem table stops at %d, not %d\n",prevmax+1,len); exit(1); } gem* poolf[len]; int poolf_length[len]; KGSPEC_COMPRESSION printf("Gem speccing pool compression done!\n"); FILE* tableA=file_check(filenameA); // fileA is open to read if (tableA==NULL) exit(1); // if the file is not good we exit int lena=len; // as long as the spec length gemY** poolY=malloc(lena*sizeof(gemY*)); int* poolY_length=malloc(lena*sizeof(int)); poolY[0]=malloc(sizeof(gemY)); poolY_length[0]=1; gem_init_Y(poolY[0],1,1,1); int prevmaxA=pool_from_table_Y(poolY, poolY_length, lena, tableA); // amps pool filling fclose(tableA); if (prevmaxA<lena-1) { for (i=0;i<=prevmaxA;++i) free(poolY[i]); // free if (prevmaxA>0) printf("Amp table stops at %d, not %d\n",prevmaxA+1,lena); exit(1); } gemY** poolYf=malloc(lena*sizeof(gemY*)); // if not malloc-ed 140k is the limit int poolYf_length[lena]; AMPS_COMPRESSION printf("Amp pool compression done!\n"); FILE* tablec=file_check(filenamec); // file is open to read if (tablec==NULL) exit(1); // if the file is not good we exit gem** poolc=malloc(lenc*sizeof(gem*)); int* poolc_length=malloc(lenc*sizeof(int)); poolc[0]=malloc(sizeof(gem)); poolc_length[0]=1; gem_init(poolc[0],1,1,1,1); int prevmaxc=pool_from_table(poolc, poolc_length, lenc, tablec); // killgem comb pool filling fclose(tablec); if (prevmaxc<lenc-1) { // if the killgems are not enough for (i=0;i<=prevmaxc;++i) free(poolc[i]); // free if (prevmaxc>0) printf("Gem table stops at %d, not %d\n",prevmaxc+1,lenc); exit(1); } gem bestc=(gem){0}; // choosing best combine for (i=0;i<poolc_length[lenc-1];++i) { if (gem_more_powerful(poolc[lenc-1][i], bestc)) { bestc=poolc[lenc-1][i]; } } double bestc_growth=log(gem_power(bestc))/log(lenc); printf("Combining pool compression done!\n\n"); int j,k,h; // let's choose the right gem-amp combo gem gems[len]; // for every speccing value gemY amps[len]; // we'll choose the best amps double powers[len]; gem_init(gems,1,1,1,0); gem_init_Y(amps,0,0,0); powers[0]=0; double crit_ratio =Namps*(0.15+As/3*0.004)*2*(1+0.03*TC)/(1.0+TC/3*0.1); double damage_ratio=Namps*(0.20+As/3*0.004) * (1+0.03*TC)/(1.2+TC/3*0.1); double NT=pow(2, GT-1); if (!(output_options & mask_quiet)) { printf("Killgem spec\n"); gem_print(gems); printf("Amplifier spec (x%d)\n", Namps); gem_print_Y(amps); printf("Spec base power: \t0\n\n\n"); } for (i=1;i<len;++i) { // for every gem value gems[i]=(gem){0}; // we init the gems amps[i]=(gemY){0}; // to extremely weak ones for (k=0;k<poolf_length[i];++k) { // first we compare the gem alone if (gem_power(poolf[i][k]) > gem_power(gems[i])) { gems[i]=poolf[i][k]; } } int NS=i+1; double C0 = pow(NT/(i+1), bestc_growth); // last we compute the combination number powers[i] = C0 * gem_power(gems[i]); // now we compare the whole setup for (j=0, NS+=Namps; j<i+1; ++j, NS+=Namps) { // for every amp value from 1 to to gem_value double Cg = pow(NT/NS, bestc_growth); // we compute the combination number for (k=0;k<poolf_length[i];++k) { // then in the gem pool double Pb2 = poolf[i][k].bbound * poolf[i][k].bbound; double Pdg = poolf[i][k].damage; double Pcg = poolf[i][k].crit ; for (h=0;h<poolYf_length[j];++h) { // and in the reduced amp pool double Pdamage = Pdg + damage_ratio* poolYf[j][h].damage ; double Pcrit = Pcg + crit_ratio * poolYf[j][h].crit ; double Pbase = Pb2 * Pdamage * Pcrit ; double power = Cg * Pbase; if (power>powers[i]) { powers[i]=power; gems[i]=poolf[i][k]; amps[i]=poolYf[j][h]; } } } } if (!(output_options & mask_quiet)) { printf("Killgem spec\n"); printf("Value:\t%d\n",i+1); if (output_options & mask_debug) printf("Pool:\t%d\n",poolf_length[i]); gem_print(gems+i); printf("Amplifier spec (x%d)\n", Namps); printf("Value:\t%d\n",gem_getvalue_Y(amps+i)); if (output_options & mask_debug) printf("Pool:\t%d\n",poolYf_length[gem_getvalue_Y(amps+i)-1]); gem_print_Y(amps+i); printf("Setup combine\n"); printf("Comb:\t%d\n",lenc); gem_print(&bestc); printf("Spec base power: \t%#.7g\n", gem_amp_power(gems[i], amps[i], damage_ratio, crit_ratio)); printf("Global power at g%d:\t%#.7g\n\n\n", GT, powers[i]); } } if (output_options & mask_quiet) { // outputs last if we never seen any printf("Killgem spec\n"); printf("Value:\t%d\n",len); gem_print(gems+len-1); printf("Amplifier spec (x%d)\n", Namps); printf("Value:\t%d\n",gem_getvalue_Y(amps+len-1)); gem_print_Y(amps+len-1); printf("Setup combine\n"); printf("Comb:\t%d\n",lenc); printf("Growth:\t%f\n", bestc_growth); gem_print(&bestc); printf("Spec base power: \t%#.7g\n", gem_amp_power(gems[len-1], amps[len-1], damage_ratio, crit_ratio)); printf("Global power at g%d:\t%#.7g\n\n\n", GT, powers[len-1]); } gem* gemf = gems+len-1; // gem that will be displayed gemY* ampf = amps+len-1; // amp that will be displayed gem* gemfc= &bestc; // gemc that will be displayed if (output_options & mask_upto) { double best_pow=0; int best_index=0; for (i=0; i<len; ++i) { if (powers[i] > best_pow) { best_index=i; best_pow=powers[i]; } } printf("Best setup up to %d:\n\n", len); printf("Killgem spec\n"); printf("Value:\t%d\n", gem_getvalue(gems+best_index)); gem_print(gems+best_index); printf("Amplifier spec (x%d)\n", Namps); printf("Value:\t%d\n", gem_getvalue_Y(amps+best_index)); gem_print_Y(amps+best_index); printf("Setup combine\n"); printf("Comb:\t%d\n",lenc); gem_print(gemfc); printf("Spec base power: \t%#.7g\n", gem_amp_power(gems[best_index], amps[best_index], damage_ratio, crit_ratio)); printf("Global power at g%d:\t%#.7g\n\n\n", GT, powers[best_index]); gemf = gems+best_index; ampf = amps+best_index; } gem* gem_array; gem red; if (output_options & mask_red) { if (len < 3) printf("I could not add red!\n\n"); else { int value = gem_getvalue(gemf); int valueA= gem_getvalue_Y(ampf); double NS = value + Namps*valueA; double amp_damage_scaled = damage_ratio * ampf->damage; double amp_crit_scaled = crit_ratio * ampf->crit; gemf = gem_putred(poolf[value-1], poolf_length[value-1], value, &red, &gem_array, amp_damage_scaled, amp_crit_scaled); printf("Setup with red added:\n\n"); printf("Killgem spec\n"); printf("Value:\t%d\n", value); // made to work well with -u gem_print(gemf); printf("Amplifier spec (x%d)\n", Namps); printf("Value:\t%d\n", valueA); gem_print_Y(ampf); printf("Setup combine\n"); printf("Comb:\t%d\n",lenc); gem_print(gemfc); printf("Spec base power with red:\t%#.7g\n", gem_amp_power(*gemf, *ampf, damage_ratio, crit_ratio)); double CgP = pow(NT/NS, bestc_growth); printf("Global power w. red at g%d:\t%#.7g\n\n\n", GT, CgP*gem_cfr_power(*gemf, amp_damage_scaled, amp_crit_scaled)); } } if (output_options & mask_parens) { printf("Killgem speccing scheme:\n"); print_parens_compressed(gemf); printf("\n\n"); printf("Amplifier speccing scheme:\n"); print_parens_compressed_Y(ampf); printf("\n\n"); printf("Setup combining scheme:\n"); print_parens_compressed(gemfc); printf("\n\n"); } if (output_options & mask_tree) { printf("Killgem speccing tree:\n"); print_tree(gemf, ""); printf("\n"); printf("Amplifier speccing tree:\n"); print_tree_Y(ampf, ""); printf("\n"); printf("Setup combining tree:\n"); print_tree(gemfc, ""); printf("\n"); } if (output_options & mask_table) print_omnia_table(gems, amps, powers, len); if (output_options & mask_equations) { // it ruins gems, must be last printf("Killgem speccing equations:\n"); print_equations(gemf); printf("\n"); printf("Amplifier speccing equations:\n"); print_equations_Y(ampf); printf("\n"); printf("Setup combining equations:\n"); print_equations(gemfc); printf("\n"); } for (i=0;i<len;++i) free(pool[i]); // free gems for (i=0;i<len;++i) free(poolf[i]); // free gems compressed for (i=0;i<lenc;++i) free(poolc[i]); // free gems free(poolc); free(poolc_length); for (i=0;i<lena;++i) free(poolY[i]); // free amps for (i=0;i<lena;++i) free(poolYf[i]); // free amps compressed free(poolY); free(poolY_length); free(poolYf); if (output_options & mask_red && len > 2) { free(gem_array); } }
void worker(int len, int output_options, char* filename) { FILE* table=table_init(filename, 1); // init orange int i; gem** pool=malloc(len*sizeof(gem*)); // if not malloc-ed 690k is the limit int* pool_length=malloc(len*sizeof(int)); pool[0]=malloc(sizeof(gem)); gem_init(pool[0],1,1); pool_length[0]=1; int prevmax=pool_from_table(pool, pool_length, len, table); // pool filling if (prevmax+1==len) { fclose(table); // close for (i=0;i<len;++i) free(pool[i]); // free free(pool); // free free(pool_length); // free printf("Table is longer than %d, no need to do anything\n\n",prevmax+1); exit(1); } table=freopen(filename,"a", table); // append -> updating possible for (i=prevmax+1; i<len; ++i) { // more building int j,k,h; const int eoc=(i+1)/ (1+1); // end of combining const int j0 =(i+1)/(10+1); // value ratio < 10 int comb_tot=0; const int grade_max=(int)(log2(i+1)+1); // gems with max grade cannot be destroyed, so this is a max, not a sup gem temp_array[grade_max-1]; // this will have all the grades for (j=0; j<grade_max-1; ++j) temp_array[j]=(gem){0}; for (j=j0; j<eoc; ++j) { // combine gems and put them in temp array for (k=0; k< pool_length[j]; ++k) { int g1=(pool[j]+k)->grade; for (h=0; h< pool_length[i-1-j]; ++h) { int delta=g1 - (pool[i-1-j]+h)->grade; if (abs(delta)<=2) { // grade difference <= 2 comb_tot++; gem temp; gem_combine(pool[j]+k, pool[i-1-j]+h, &temp); int grd=temp.grade-2; if (gem_better(temp, temp_array[grd])) { temp_array[grd]=temp; } } } } } int gemNum=0; for (j=0; j<grade_max-1; ++j) if (temp_array[j].grade!=0) gemNum++; pool_length[i]=gemNum; pool[i]=malloc(pool_length[i]*sizeof(gem)); int place=0; for (j=0; j<grade_max-1; ++j) { // copying to pool if (temp_array[j].grade!=0) { pool[i][place]=temp_array[j]; place++; } } if (!(output_options & mask_quiet)) { printf("Value:\t%d\n",i+1); if (output_options & mask_debug) { printf("Raw:\t%d\n",comb_tot); printf("Pool:\t%d\n\n",pool_length[i]); } } table_write_iteration(pool, pool_length, i, table); // write on file } fclose(table); // close for (i=0;i<len;++i) free(pool[i]); // free free(pool); // free free(pool_length); // free }
static void zynq_init(QEMUMachineInitArgs *args) { ram_addr_t ram_size = args->ram_size; const char *cpu_model = args->cpu_model; const char *kernel_filename = args->kernel_filename; const char *kernel_cmdline = args->kernel_cmdline; const char *initrd_filename = args->initrd_filename; ARMCPU *cpu; MemoryRegion *address_space_mem = get_system_memory(); MemoryRegion *ext_ram = g_new(MemoryRegion, 1); MemoryRegion *ocm_ram = g_new(MemoryRegion, 1); DeviceState *dev; SysBusDevice *busdev; qemu_irq *irqp; qemu_irq pic[64]; NICInfo *nd; int n; qemu_irq cpu_irq; if (!cpu_model) { cpu_model = "cortex-a9"; } cpu = cpu_arm_init(cpu_model); if (!cpu) { fprintf(stderr, "Unable to find CPU definition\n"); exit(1); } irqp = arm_pic_init_cpu(cpu); cpu_irq = irqp[ARM_PIC_CPU_IRQ]; /* max 2GB ram */ if (ram_size > 0x80000000) { ram_size = 0x80000000; } /* DDR remapped to address zero. */ memory_region_init_ram(ext_ram, "zynq.ext_ram", ram_size); vmstate_register_ram_global(ext_ram); memory_region_add_subregion(address_space_mem, 0, ext_ram); /* 256K of on-chip memory */ memory_region_init_ram(ocm_ram, "zynq.ocm_ram", 256 << 10); vmstate_register_ram_global(ocm_ram); memory_region_add_subregion(address_space_mem, 0xFFFC0000, ocm_ram); DriveInfo *dinfo = drive_get(IF_PFLASH, 0, 0); /* AMD */ pflash_cfi02_register(0xe2000000, NULL, "zynq.pflash", FLASH_SIZE, dinfo ? dinfo->bdrv : NULL, FLASH_SECTOR_SIZE, FLASH_SIZE/FLASH_SECTOR_SIZE, 1, 1, 0x0066, 0x0022, 0x0000, 0x0000, 0x0555, 0x2aa, 0); dev = qdev_create(NULL, "xilinx,zynq_slcr"); qdev_init_nofail(dev); sysbus_mmio_map(sysbus_from_qdev(dev), 0, 0xF8000000); dev = qdev_create(NULL, "a9mpcore_priv"); qdev_prop_set_uint32(dev, "num-cpu", 1); qdev_init_nofail(dev); busdev = sysbus_from_qdev(dev); sysbus_mmio_map(busdev, 0, 0xF8F00000); sysbus_connect_irq(busdev, 0, cpu_irq); for (n = 0; n < 64; n++) { pic[n] = qdev_get_gpio_in(dev, n); } zynq_init_spi_flashes(0xE0006000, pic[58-IRQ_OFFSET]); zynq_init_spi_flashes(0xE0007000, pic[81-IRQ_OFFSET]); sysbus_create_simple("cadence_uart", 0xE0000000, pic[59-IRQ_OFFSET]); sysbus_create_simple("cadence_uart", 0xE0001000, pic[82-IRQ_OFFSET]); sysbus_create_varargs("cadence_ttc", 0xF8001000, pic[42-IRQ_OFFSET], pic[43-IRQ_OFFSET], pic[44-IRQ_OFFSET], NULL); sysbus_create_varargs("cadence_ttc", 0xF8002000, pic[69-IRQ_OFFSET], pic[70-IRQ_OFFSET], pic[71-IRQ_OFFSET], NULL); for (n = 0; n < nb_nics; n++) { nd = &nd_table[n]; if (n == 0) { gem_init(nd, 0xE000B000, pic[54-IRQ_OFFSET]); } else if (n == 1) { gem_init(nd, 0xE000C000, pic[77-IRQ_OFFSET]); } } zynq_binfo.ram_size = ram_size; zynq_binfo.kernel_filename = kernel_filename; zynq_binfo.kernel_cmdline = kernel_cmdline; zynq_binfo.initrd_filename = initrd_filename; zynq_binfo.nb_cpus = 1; zynq_binfo.board_id = 0xd32; zynq_binfo.loader_start = 0; arm_load_kernel(arm_env_get_cpu(first_cpu), &zynq_binfo); }
void worker(int len, int output_options, char* filename) { FILE* table=table_init(filename, 1); // init killgem int i; gem** pool=malloc(len*sizeof(gem*)); // win 262k int* pool_length=malloc(len*sizeof(int)); pool[0]=malloc(sizeof(gem)); pool_length[0]=1; gem_init(pool[0],1,1,1,1); // grade damage crit bbound int prevmax=pool_from_table(pool, pool_length, len, table); // pool filling if (prevmax+1==len) { fclose(table); for (i=0;i<len;++i) free(pool[i]); // free printf("Table is longer than %d, no need to do anything\n\n",prevmax+1); exit(1); } table=freopen(filename,"a", table); // append -> updating possible for (i=prevmax+1; i<len; ++i) { int j,k,h; const int eoc=(i+1)/ (1+1); // end of combining const int j0 =(i+1)/(10+1); // value ratio < 10 int comb_tot=0; const int ngrades=(int)log2(i+1); const int temp_length=nchecks*ngrades; gem temp_array[temp_length]; // this will have all the grades for (j=0; j<temp_length; ++j) temp_array[j]=(gem){0}; double pow_array[temp_length]; // this will have all the powers for (j=0; j<temp_length; ++j) pow_array[j]=0; for (j=j0; j<eoc; ++j) { // combine gems and put them in temp array for (k=0; k< pool_length[j]; ++k) { int g1=(pool[j]+k)->grade; for (h=0; h< pool_length[i-1-j]; ++h) { int delta=g1 - (pool[i-1-j]+h)->grade; if (abs(delta)<=2) { // grade difference <= 2 comb_tot++; gem temp; gem_combine(pool[j]+k, pool[i-1-j]+h, &temp); int grd=temp.grade-2; int p0 = grd*nchecks; if ( gem_rk511(temp) >= pow_array[p0] ) { // rk511 check pow_array[p0]=gem_rk511(temp); temp_array[p0]=temp; } else if ( gem_power(temp) >= pow_array[p0+1] ) { // rk211 check pow_array[p0+1]=gem_power(temp); temp_array[p0+1]=temp; } else if ( gem_rk411(temp) >= pow_array[p0+2] ) { // rk411 check pow_array[p0+2]=gem_rk411(temp); temp_array[p0+2]=temp; } else if ( gem_rk311(temp) >= pow_array[p0+3] ) { // rk311 check pow_array[p0+3]=gem_rk311(temp); temp_array[p0+3]=temp; } else if ( gem_power(temp) >= pow_array[p0+4] ) { // rk211 check pow_array[p0+4]=gem_power(temp); temp_array[p0+4]=temp; } else if ( gem_power(temp) >= pow_array[p0+5] ) { // rk211 check pow_array[p0+5]=gem_power(temp); temp_array[p0+5]=temp; } } } } } int gemNum=0; for (j=0; j<temp_length; ++j) if (temp_array[j].grade!=0) gemNum++; pool_length[i]=gemNum; pool[i]=malloc(pool_length[i]*sizeof(gem)); int place=0; for (j=0; j<temp_length; ++j) { // copying to pool if (temp_array[j].grade!=0) { pool[i][place]=temp_array[j]; place++; } } if (!(output_options & mask_quiet)) { printf("Value:\t%d\n",i+1); if (output_options & mask_debug) { printf("Raw:\t%d\n",comb_tot); printf("Pool:\t%d\n\n",pool_length[i]); } } table_write_iteration(pool, pool_length, i, table); // write on file } fclose(table); // close for (i=0;i<len;++i) free(pool[i]); // free free(pool); // free free(pool_length); // free }
void worker(int len, int lenc, int output_options, char* filename, char* filenamec, char* filenameA, int TC, int As, int GT, int Namps) { FILE* table=file_check(filename); // file is open to read if (table==NULL) exit(1); // if the file is not good we exit int i; gem* pool[len]; int pool_length[len]; pool[0]=malloc(2*sizeof(gem)); pool_length[0]=2; gem_init(pool[0] ,1,1.000000,1,0); // grade damage crit bbound gem_init(pool[0]+1,1,1.186168,0,1); // BB has more dmg int prevmax=pool_from_table(pool, pool_length, len, table); // killgem spec pool filling fclose(table); if (prevmax<len-1) { // if the killgems are not enough for (i=0;i<=prevmax;++i) free(pool[i]); // free if (prevmax>0) printf("Gem table stops at %d, not %d\n",prevmax+1,len); exit(1); } gem* poolf[len]; int poolf_length[len]; KGSPEC_COMPRESSION printf("Gem speccing pool compression done!\n"); FILE* tableA=file_check(filenameA); // fileA is open to read if (tableA==NULL) exit(1); // if the file is not good we exit int lena=len; // see which is bigger between spec len and comb len if (lenc > len) lena=lenc; // and we'll get the amp pool till there gemY** poolY=malloc(lena*sizeof(gemY*)); int* poolY_length=malloc(lena*sizeof(int)); poolY[0]=malloc(sizeof(gemY)); poolY_length[0]=1; gem_init_Y(poolY[0],1,1,1); int prevmaxA=pool_from_table_Y(poolY, poolY_length, lena, tableA); // amps pool filling fclose(tableA); if (prevmaxA<lena-1) { for (i=0;i<=prevmaxA;++i) free(poolY[i]); // free if (prevmaxA>0) printf("Amp table stops at %d, not %d\n",prevmaxA+1,lena); exit(1); } gemY** poolYf=malloc(lena*sizeof(gemY*)); // if not malloc-ed 140k is the limit int poolYf_length[lena]; AMPS_COMPRESSION gemY poolYc[poolYf_length[lenc-1]]; int poolYc_length=poolYf_length[lenc-1]; for (i=0; i<poolYf_length[lenc-1]; ++i) { // amps fast access combining pool poolYc[i]=poolYf[lenc-1][i]; } printf("Amp combining pool compression done!\n"); FILE* tablec=file_check(filenamec); // file is open to read if (tablec==NULL) exit(1); // if the file is not good we exit gem** poolc=malloc(lenc*sizeof(gem*)); int* poolc_length=malloc(lenc*sizeof(int)); poolc[0]=malloc(sizeof(gem)); poolc_length[0]=1; gem_init(poolc[0],1,1,1,1); int prevmaxc=pool_from_table(poolc, poolc_length, lenc, tablec); // killgem comb pool filling fclose(tablec); if (prevmaxc<lenc-1) { // if the killgems are not enough for (i=0;i<=prevmaxc;++i) free(poolc[i]); // free if (prevmaxc>0) printf("Gem table stops at %d, not %d\n",prevmaxc+1,lenc); exit(1); } gem* poolcf; int poolcf_length; KGCOMB_COMPRESSION printf("Killgem comb compressed pool size:\t%d\n",poolcf_length); int cpairs_length; cpair* cpairs; { // cpair compression int length = poolcf_length*poolYc_length; cpair* temp_array=malloc(length*sizeof(cpair)); int index=0; for (int l=0; l<poolcf_length; ++l) { for (int m=0; m<poolYc_length; ++m) { double power = gem_power(poolcf[l]); double rdmg = poolYc[m].damage/poolcf[l].damage; double rcrit = poolYc[m].crit / poolcf[l].crit; temp_array[index++] = (cpair){power, rdmg, rcrit, poolcf+l, poolYc+m, 0}; } } cpair_sort_rcrit(temp_array,length); /* work starts */ double lastrcrit=-1; int tree_cell=0; for (int l=0; l<length; ++l) { if (temp_array[l].rcrit == lastrcrit) temp_array[l].place=tree_cell-1; else { temp_array[l].place=tree_cell++; lastrcrit = temp_array[l].rcrit; } } cpair_sort_xyz(temp_array,length); int broken=0; int tree_length= 1 << (int)ceil(log2(tree_cell)); /* this is pow(2, ceil()) bitwise */ double* tree=malloc((tree_length*2)*sizeof(double)); for (int l=0; l<tree_length*2; ++l) tree[l]=0; /* init also tree[0], it's faster */ for (int l=length-1; l>=0; --l) { /* start from large rdmg */ cpair* p_cpair=temp_array+l; if (dtree_check_after(tree, tree_length, p_cpair->place, p_cpair->power)) { dtree_add_element(tree, tree_length, p_cpair->place, p_cpair->power); } else { p_cpair->combg=NULL; broken++; } } for (int l=0; l<tree_length*2; ++l) tree[l]=0; /* BgDaCa - iDa - iCa compression */ for (int l=0; l<length; ++l) { /* start from low rdmg */ cpair* p_cpair=temp_array+l; if (p_cpair->combg==NULL) continue; int place = tree_length -1 - p_cpair->place; /* reverse crit order */ if (dtree_check_after(tree, tree_length, place, cpair_BgDaCa(*p_cpair))) { dtree_add_element(tree, tree_length, place, cpair_BgDaCa(*p_cpair)); } else { p_cpair->combg=NULL; broken++; } } for (int l=0; l<tree_length*2; ++l) tree[l]=0; /* BgDaCg - iDa - Ca compression */ for (int l=0; l<length; ++l) { /* start from low rdmg */ cpair* p_cpair=temp_array+l; if (p_cpair->combg==NULL) continue; int place = p_cpair->place; /* regular crit order */ if (dtree_check_after(tree, tree_length, place, cpair_BgDaCg(*p_cpair))) { dtree_add_element(tree, tree_length, place, cpair_BgDaCg(*p_cpair)); } else { p_cpair->combg=NULL; broken++; } } for (int l=0; l<tree_length*2; ++l) tree[l]=0; /* BgDgCa - Da - iCa compression */ for (int l=length-1; l>=0; --l) { /* start from large rdmg */ cpair* p_cpair=temp_array+l; if (p_cpair->combg==NULL) continue; int place = tree_length -1 - p_cpair->place; /* reverse crit order */ if (dtree_check_after(tree, tree_length, place, cpair_BgDgCa(*p_cpair))) { dtree_add_element(tree, tree_length, place, cpair_BgDgCa(*p_cpair)); } else { p_cpair->combg=NULL; broken++; } } free(tree); cpairs_length=length-broken; cpairs=malloc(cpairs_length*sizeof(cpair)); index=0; for (int j=0; j<length; ++j) { if (temp_array[j].combg!=NULL) { cpairs[index] = temp_array[j]; index++; } } free(temp_array); } printf("Combine pairs pool size:\t%d\n\n",cpairs_length); int j,k,h,l; // let's choose the right gem-amp combo gem gems[len]; // for every speccing value gemY amps[len]; // we'll choose the best amps gem gemsc[len]; // and the best NC combine gemY ampsc[len]; // for both double powers[len]; gem_init(gems,1,1,1,0); gem_init_Y(amps,0,0,0); gem_init(gemsc,1,1,0,0); gem_init_Y(ampsc,0,0,0); powers[0]=0; double iloglenc=1/log(lenc); double crit_ratio =Namps*(0.15+As/3*0.004)*2*(1+0.03*TC)/(1.0+TC/3*0.1); double damage_ratio=Namps*(0.20+As/3*0.004) * (1+0.03*TC)/(1.2+TC/3*0.1); double NT=pow(2, GT-1); if (!(output_options & mask_quiet)) { printf("Killgem spec\n"); gem_print(gems); printf("Amplifier spec (x%d)\n", Namps); gem_print_Y(amps); printf("Spec base power: \t0\n\n\n"); } for (i=1;i<len;++i) { // for every gem value gems[i]=(gem){0}; // we init the gems amps[i]=(gemY){0}; // to extremely weak ones gemsc[i]=(gem){0}; ampsc[i]=(gemY){0}; // first we compare the gem alone for (l=0; l<poolcf_length; ++l) { // first search in the NC gem comb pool if (gem_power(poolcf[l]) > gem_power(gemsc[i])) { gemsc[i]=poolcf[l]; } } for (k=0;k<poolf_length[i];++k) { // and then in the compressed gem pool if (gem_power(poolf[i][k]) > gem_power(gems[i])) { gems[i]=poolf[i][k]; } } int NS=i+1; double c0 = log(NT/(i+1))*iloglenc; // last we compute the combination number powers[i] = pow(gem_power(gemsc[i]),c0) * gem_power(gems[i]); // now we compare the whole setup for (j=0, NS+=Namps; j<i+1; ++j, NS+=Namps) { // for every amp value from 1 to to gem_value double c = log(NT/NS)*iloglenc; // we compute the combination number for (l=0; l<cpairs_length; ++l) { // then we search in the comb pair pool double Cg = pow(cpairs[l].power,c); double Rd = damage_ratio*pow(cpairs[l].rdmg, c); double Rc = crit_ratio * pow(cpairs[l].rcrit,c); for (h=0; h<poolYf_length[j]; ++h) { // then in the reduced amp pool double Pad = Rd * poolYf[j][h].damage; double Pac = Rc * poolYf[j][h].crit ; for (k=0; k<poolf_length[i]; ++k) { // and in the gem pool double Pext = Cg * poolf[i][k].bbound * poolf[i][k].bbound; double Pdamage = poolf[i][k].damage + Pad; double Pcrit = poolf[i][k].crit + Pac; double power = Pext * Pdamage * Pcrit ; if (power>powers[i]) { powers[i]=power; gems[i]=poolf[i][k]; amps[i]=poolYf[j][h]; gemsc[i]=*(cpairs[l].combg); ampsc[i]=*(cpairs[l].comba); } } } } } if (!(output_options & mask_quiet)) { printf("Killgem spec\n"); printf("Value:\t%d\n",i+1); if (output_options & mask_debug) printf("Pool:\t%d\n",poolf_length[i]); gem_print(gems+i); printf("Amplifier spec (x%d)\n", Namps); printf("Value:\t%d\n",gem_getvalue_Y(amps+i)); if (output_options & mask_debug) printf("Pool:\t%d\n",poolYf_length[gem_getvalue_Y(amps+i)-1]); gem_print_Y(amps+i); printf("Killgem combine\n"); printf("Comb:\t%d\n",lenc); if (output_options & mask_debug) printf("P.pool:\t%d\n", cpairs_length); gem_print(gemsc+i); printf("Amplifier combine\n"); printf("Comb:\t%d\n",lenc); gem_print_Y(ampsc+i); printf("Spec base power: \t%#.7g\n", gem_amp_power(gems[i], amps[i], damage_ratio, crit_ratio)); printf("Global power at g%d:\t%#.7g\n\n\n", GT, powers[i]); } } if (output_options & mask_quiet) { // outputs last if we never seen any printf("Killgem spec\n"); printf("Value:\t%d\n",len); gem_print(gems+len-1); printf("Amplifier spec (x%d)\n", Namps); printf("Value:\t%d\n",gem_getvalue_Y(amps+len-1)); gem_print_Y(amps+len-1); printf("Killgem combine\n"); printf("Comb:\t%d\n",lenc); if (output_options & mask_debug) printf("P.pool:\t%d\n", cpairs_length); gem_print(gemsc+len-1); printf("Amplifier combine\n"); printf("Comb:\t%d\n",lenc); gem_print_Y(ampsc+len-1); printf("Spec base power: \t%#.7g\n", gem_amp_power(gems[len-1], amps[len-1], damage_ratio, crit_ratio)); printf("Global power at g%d:\t%#.7g\n\n\n", GT, powers[len-1]); } gem* gemf = gems+len-1; // gem that will be displayed gemY* ampf = amps+len-1; // amp that will be displayed gem* gemfc=gemsc+len-1; // gemc that will be displayed gemY* ampfc=ampsc+len-1; // ampc that will be displayed if (output_options & mask_upto) { double best_pow=0; int best_index=0; for (i=0; i<len; ++i) { if (powers[i] > best_pow) { best_index=i; best_pow=powers[i]; } } printf("Best setup up to %d:\n\n", len); printf("Killgem spec\n"); printf("Value:\t%d\n", gem_getvalue(gems+best_index)); gem_print(gems+best_index); printf("Amplifier spec (x%d)\n", Namps); printf("Value:\t%d\n", gem_getvalue_Y(amps+best_index)); gem_print_Y(amps+best_index); printf("Killgem combine\n"); printf("Comb:\t%d\n",lenc); gem_print(gemsc+best_index); printf("Amplifier combine\n"); printf("Comb:\t%d\n",lenc); gem_print_Y(ampsc+best_index); printf("Spec base power: \t%#.7g\n", gem_amp_power(gems[best_index], amps[best_index], damage_ratio, crit_ratio)); printf("Global power at g%d:\t%#.7g\n\n\n", GT, powers[best_index]); gemf = gems+best_index; ampf = amps+best_index; gemfc = gemsc+best_index; ampfc = ampsc+best_index; } gem* gem_array; gem red; if (output_options & mask_red) { if (len < 3) printf("I could not add red!\n\n"); else { int value=gem_getvalue(gemf); int valueA= gem_getvalue_Y(ampf); double NS = value + Namps*valueA; double c = log(NT/NS)*iloglenc; double ampd_resc_coeff = pow((ampfc->damage/gemfc->damage), c); double ampc_resc_coeff = pow((ampfc->crit/gemfc->crit), c); double amp_damage_scaled = damage_ratio * ampd_resc_coeff * ampf->damage; double amp_crit_scaled = crit_ratio * ampc_resc_coeff * ampf->crit; gemf = gem_putred(poolf[value-1], poolf_length[value-1], value, &red, &gem_array, amp_damage_scaled, amp_crit_scaled); printf("Setup with red added:\n\n"); printf("Killgem spec\n"); printf("Value:\t%d\n", value); // made to work well with -u gem_print(gemf); printf("Amplifier spec (x%d)\n", Namps); printf("Value:\t%d\n", valueA); gem_print_Y(ampf); printf("Killgem combine\n"); printf("Comb:\t%d\n",lenc); gem_print(gemfc); printf("Amplifier combine\n"); printf("Comb:\t%d\n",lenc); gem_print_Y(ampfc); if (output_options & mask_debug) printf("Damage rescaling coeff.: \t%f\n", ampd_resc_coeff); if (output_options & mask_debug) printf("Crit rescaling coeff.: \t%f\n", ampc_resc_coeff); printf("Spec base power with red:\t%#.7g\n", gem_amp_power(*gemf, *ampf, damage_ratio, crit_ratio)); double CgP = pow(gem_power(*gemfc), c); printf("Global power w. red at g%d:\t%#.7g\n\n\n", GT, CgP*gem_cfr_power(*gemf, amp_damage_scaled, amp_crit_scaled)); } } if (output_options & mask_parens) { printf("Killgem speccing scheme:\n"); print_parens_compressed(gemf); printf("\n\n"); printf("Amplifier speccing scheme:\n"); print_parens_compressed_Y(ampf); printf("\n\n"); printf("Killgem combining scheme:\n"); print_parens_compressed(gemfc); printf("\n\n"); printf("Amplifier combining scheme:\n"); print_parens_compressed_Y(ampfc); printf("\n\n"); } if (output_options & mask_tree) { printf("Killgem speccing tree:\n"); print_tree(gemf, ""); printf("\n"); printf("Amplifier speccing tree:\n"); print_tree_Y(ampf, ""); printf("\n"); printf("Killgem combining tree:\n"); print_tree(gemfc, ""); printf("\n"); printf("Amplifier combining tree:\n"); print_tree_Y(ampfc, ""); printf("\n"); } if (output_options & mask_table) print_omnia_table(gems, amps, powers, len); if (output_options & mask_equations) { // it ruins gems, must be last printf("Killgem speccing equations:\n"); print_equations(gemf); printf("\n"); printf("Amplifier speccing equations:\n"); print_equations_Y(ampf); printf("\n"); printf("Killgem combining equations:\n"); print_equations(gemfc); printf("\n"); printf("Amplifier combining equations:\n"); print_equations_Y(ampfc); printf("\n"); } for (i=0;i<len;++i) free(pool[i]); // free gems for (i=0;i<len;++i) free(poolf[i]); // free gems compressed for (i=0;i<lenc;++i) free(poolc[i]); // free gems free(poolc); free(poolc_length); free(poolcf); for (i=0;i<lena;++i) free(poolY[i]); // free amps for (i=0;i<lena;++i) free(poolYf[i]); // free amps compressed free(poolY); free(poolY_length); free(poolYf); free(cpairs); if (output_options & mask_red && len > 2) { free(gem_array); } }
void worker(int len, int output_options, double growth_comb, char* filename, char* filenameA, int TC, int As, int Namps) { FILE* table=file_check(filename); // file is open to read if (table==NULL) exit(1); // if the file is not good we exit int i; gem* pool[len]; int pool_length[len]; pool[0]=malloc(2*sizeof(gem)); pool_length[0]=2; gem_init(pool[0] ,1,1,0); gem_init(pool[0]+1,1,0,1); int prevmax=pool_from_table(pool, pool_length, len, table); // managem pool filling fclose(table); if (prevmax<len-1) { // if the managems are not enough for (i=0;i<=prevmax;++i) free(pool[i]); // free if (prevmax>0) printf("Gem table stops at %d, not %d\n",prevmax+1,len); exit(1); } gem* poolf[len]; int poolf_length[len]; MGSPEC_COMPRESSION if (!(output_options & mask_quiet)) printf("Gem speccing pool compression done!\n"); FILE* tableA=file_check(filenameA); // fileA is open to read if (tableA==NULL) exit(1); // if the file is not good we exit int lena=len; gemO* poolO[lena]; int poolO_length[lena]; poolO[0]=malloc(sizeof(gemO)); poolO_length[0]=1; gem_init_O(poolO[0],1,1); int prevmaxA=pool_from_table_O(poolO, poolO_length, lena, tableA); // amps pool filling fclose(tableA); if (prevmaxA<lena-1) { for (i=0;i<=prevmaxA;++i) free(poolO[i]); // free if (prevmaxA>0) printf("Amp table stops at %d, not %d\n",prevmaxA+1,lena); exit(1); } gemO* bestO=malloc(lena*sizeof(gemO)); // if not malloc-ed 140k is the limit AMPS_COMPRESSION if (!(output_options & mask_quiet)) printf("Amp pool compression done!\n\n"); int j,k; // let's choose the right gem-amp combo gem gems[len]; gemO amps[len]; double spec_coeffs[len]; gem_init(gems,1,1,0); amps[0]=(gemO){0}; spec_coeffs[0]=0; double leech_ratio=Namps*(0.15+As/3*0.004)*2*(1+0.03*TC)/(1+TC/3*0.1); int skip_computations = (output_options & mask_quiet) && !((output_options & mask_table) || (output_options & mask_upto)); int first = skip_computations ? len-1 : 0; for (i=first; i<len; ++i) { // for every gem value gems[i]=(gem){0}; // we init the gems amps[i]=(gemO){0}; // to extremely weak ones for (k=0;k<poolf_length[i];++k) { // first we compare the gem alone if (gem_power(poolf[i][k]) > gem_power(gems[i])) { gems[i]=poolf[i][k]; } } int NS=i+1; double comb_coeff=pow(NS, -growth_comb); spec_coeffs[i]=comb_coeff*gem_power(gems[i]); // now with amps for (j=0, NS+=Namps; j<i+1; ++j, NS+=Namps) { // for every amp value from 1 to to gem_value double comb_coeff=pow(NS, -growth_comb); // we compute comb_coeff double Pa= leech_ratio * bestO[j].leech; // <- this is ok only for mg for (k=0; k<poolf_length[i]; ++k) { // then we search in the reduced gem pool double Palone = gem_power(poolf[i][k]); double power = Palone + poolf[i][k].bbound * Pa; double spec_coeff=power*comb_coeff; if (spec_coeff>spec_coeffs[i]) { spec_coeffs[i]=spec_coeff; gems[i]=poolf[i][k]; amps[i]=bestO[j]; } } } if (!(output_options & mask_quiet)) { printf("Total value:\t%d\n\n", i+1+Namps*gem_getvalue_O(amps+i)); printf("Managem\n"); printf("Value:\t%d\n",i+1); if (output_options & mask_debug) printf("Pool:\t%d\n",poolf_length[i]); gem_print(gems+i); printf("Amplifier (x%d)\n", Namps); printf("Value:\t%d\n",gem_getvalue_O(amps+i)); gem_print_O(amps+i); printf("Spec base power: \t%#.7g\n", gem_amp_power(gems[i], amps[i], leech_ratio)); printf("Spec coefficient:\t%f\n\n", spec_coeffs[i]); } } if (output_options & mask_quiet) { // outputs last if we never seen any printf("Total value:\t%d\n\n", len+Namps*gem_getvalue_O(amps+len-1)); printf("Managem\n"); printf("Value:\t%d\n", len); gem_print(gems+len-1); printf("Amplifier (x%d)\n", Namps); printf("Value:\t%d\n", gem_getvalue_O(amps+len-1)); gem_print_O(amps+len-1); printf("Spec base power: \t%#.7g\n", gem_amp_power(gems[len-1], amps[len-1], leech_ratio)); printf("Spec coefficient:\t%f\n\n", spec_coeffs[len-1]); } gem* gemf=gems+len-1; // gem that will be displayed gemO* ampf=amps+len-1; // amp that will be displayed if (output_options & mask_upto) { double best_sc=0; int best_index=0; for (i=0; i<len; ++i) { if (spec_coeffs[i] > best_sc) { best_index=i; best_sc=spec_coeffs[i]; } } printf("Best setup up to %d:\n\n", len); printf("Total value:\t%d\n\n", gem_getvalue(gems+best_index)+Namps*gem_getvalue_O(amps+best_index)); printf("Managem\n"); printf("Value:\t%d\n", gem_getvalue(gems+best_index)); gem_print(gems+best_index); printf("Amplifier (x%d)\n", Namps); printf("Value:\t%d\n", gem_getvalue_O(amps+best_index)); gem_print_O(amps+best_index); printf("Spec base power: \t%#.7g\n", gem_amp_power(gems[best_index], amps[best_index], leech_ratio)); printf("Spec coefficient:\t%f\n\n", best_sc); gemf = gems+best_index; ampf = amps+best_index; } gem* gem_array = NULL; gem red; if (output_options & mask_red) { if (len < 3) printf("I could not add red!\n\n"); else { int value = gem_getvalue(gemf); int valueA= gem_getvalue_O(ampf); double NS = value + Namps*valueA; double amp_leech_scaled = leech_ratio * ampf->leech; gemf = gem_putred(poolf[value-1], poolf_length[value-1], value, &red, &gem_array, amp_leech_scaled); printf("Setup with red added:\n\n"); printf("Total value:\t%d\n\n", value+Namps*gem_getvalue_O(ampf)); printf("Managem\n"); printf("Value:\t%d\n", value); gem_print(gemf); printf("Amplifier (x%d)\n", Namps); printf("Value:\t%d\n", gem_getvalue_O(ampf)); gem_print_O(ampf); printf("Spec base power w. red:\t%#.7g\n", gem_amp_power(*gemf, *ampf, leech_ratio)); double CgP = pow(NS, -growth_comb); printf("Spec coefficient:\t%f\n\n", CgP*gem_cfr_power(*gemf, amp_leech_scaled)); } } if (output_options & mask_parens) { printf("Managem speccing scheme:\n"); print_parens_compressed(gemf); printf("\n\n"); printf("Amplifier speccing scheme:\n"); print_parens_compressed_O(ampf); printf("\n\n"); } if (output_options & mask_tree) { printf("Managem tree:\n"); print_tree(gemf, ""); printf("\n"); printf("Amplifier tree:\n"); print_tree_O(ampf, ""); printf("\n"); } if (output_options & mask_table) print_amps_table(gems, amps, spec_coeffs, leech_ratio, len); if (output_options & mask_equations) { // it ruins gems, must be last printf("Managem equations:\n"); print_equations(gemf); printf("\n"); printf("Amplifier equations:\n"); print_equations_O(ampf); printf("\n"); } for (i=0;i<len;++i) free(pool[i]); // free gems for (i=0;i<len;++i) free(poolf[i]); // free gems compressed for (i=0;i<lena;++i) free(poolO[i]); // free amps free(bestO); // free amps compressed if (output_options & mask_red && len > 2) { free(gem_array); } }
void worker(int len, int output_options, int pool_zero) { printf("\n"); int i; int size; const int ACC_TR=750; // 750 ACC_TR is for bbound comparisons inside tree gem gems[len]; gem* pool[len]; int pool_length[len]; pool[0]=malloc(pool_zero*sizeof(gem)); pool_length[0]=pool_zero; if (pool_zero==1) { // combine ACC=80; // ACC is for z-axis sorting and for the length of the interval tree gem_init(pool[0],1,1,1,1); // start gem does not matter gem_init(gems ,1,1,1,1); // grade damage crit bbound size=1000; // reasonable comb sizing } else { // spec ACC=60; // ACC is for z-axis sorting and for the length of the interval tree gem_init(pool[0] ,1,1.000000,1,0); gem_init(pool[0]+1,1,1.186168,0,1); // BB has more dmg gem_init(gems ,1,1.000000,1,0); // grade damage crit bbound size=20000; // reasonable spec sizing } if (!(output_options & mask_quiet)) gem_print(gems); for (i=1; i<len; ++i) { int j,k,h,l; const int eoc=(i+1)/ (1+1); // end of combining const int j0 =(i+1)/(10+1); // value ratio < 10 int comb_tot=0; int grade_max=(int)(log2(i+1)+1); // gems with max grade cannot be destroyed, so this is a max, not a sup gem* temp_pools[grade_max-1]; // get the temp pools for every grade int temp_index[grade_max-1]; // index of work point in temp pools gem* subpools[grade_max-1]; // get subpools for every grade int subpools_length[grade_max-1]; for (j=0; j<grade_max-1; ++j) { // init everything temp_pools[j]=malloc(size*sizeof(gem)); temp_index[j]=0; subpools[j]=NULL; // just to be able to free it subpools_length[j]=0; } for (j=j0; j<eoc; ++j) { // combine gems and put them in temp array for (k=0; k< pool_length[j]; ++k) { int g1=(pool[j]+k)->grade; for (h=0; h< pool_length[i-1-j]; ++h) { int delta=g1 - (pool[i-1-j]+h)->grade; if (abs(delta)<=2) { // grade difference <= 2 comb_tot++; gem temp; gem_combine(pool[j]+k, pool[i-1-j]+h, &temp); int grd=temp.grade-2; temp_pools[grd][temp_index[grd]]=temp; temp_index[grd]++; if (temp_index[grd]==size) { // let's skim a pool int length=size+subpools_length[grd]; gem* temp_array=malloc(length*sizeof(gem)); int index=0; float maxcrit=0; // this will help me create the minimum tree for (l=0; l<size; ++l) { // copy new gems temp_array[index]=temp_pools[grd][l]; maxcrit=max(maxcrit, (temp_array+index)->crit); index++; } temp_index[grd]=0; // temp index reset for (l=0; l<subpools_length[grd]; ++l) { // copy old gems temp_array[index]=subpools[grd][l]; maxcrit=max(maxcrit, (temp_array+index)->crit); index++; } free(subpools[grd]); // free gem_sort(temp_array,length); // work starts int broken=0; int crit_cells=(int)(maxcrit*ACC)+1; // this pool will be big from the beginning, but we avoid binary search int tree_length= 1 << (int)ceil(log2(crit_cells)); // this is pow(2, ceil()) bitwise for speed improvement int* tree=malloc((tree_length+crit_cells+1)*sizeof(int)); // memory improvement, 2* is not needed for (l=0; l<tree_length+crit_cells+1; ++l) tree[l]=-1; // init also tree[0], it's faster for (l=length-1;l>=0;--l) { // start from large z gem* p_gem=temp_array+l; int index=(int)(p_gem->crit*ACC); // find its place in x if (tree_check_after(tree, tree_length, index, (int)(p_gem->bbound*ACC_TR))) { // look at y tree_add_element(tree, tree_length, index, (int)(p_gem->bbound*ACC_TR)); } else { p_gem->grade=0; broken++; } } // all unnecessary gems destroyed free(tree); // free subpools_length[grd]=length-broken; subpools[grd]=malloc(subpools_length[grd]*sizeof(gem)); // pool init via broken index=0; for (l=0; l<length; ++l) { // copying to subpool if (temp_array[l].grade!=0) { subpools[grd][index]=temp_array[l]; index++; } } free(temp_array); // free } // rebuilt subpool[grd], work restarts } } } } int grd; for (grd=0; grd<grade_max-1; ++grd) { // let's put remaining gems on if (temp_index[grd] != 0) { int length=temp_index[grd]+subpools_length[grd]; gem* temp_array=malloc(length*sizeof(gem)); int index=0; float maxcrit=0; // this will help me create the minimum tree for (l=0; l<temp_index[grd]; ++l) { // copy new gems temp_array[index]=temp_pools[grd][l]; maxcrit=max(maxcrit, (temp_array+index)->crit); index++; } for (l=0; l<subpools_length[grd]; ++l) { // copy old gems temp_array[index]=subpools[grd][l]; maxcrit=max(maxcrit, (temp_array+index)->crit); index++; } free(subpools[grd]); // free gem_sort(temp_array,length); // work starts int broken=0; int crit_cells=(int)(maxcrit*ACC)+1; // this pool will be big from the beginning, but we avoid binary search int tree_length= 1 << (int)ceil(log2(crit_cells)); // this is pow(2, ceil()) bitwise for speed improvement int* tree=malloc((tree_length+crit_cells+1)*sizeof(int)); // memory improvement, 2* is not needed for (l=0; l<tree_length+crit_cells+1; ++l) tree[l]=-1; // init also tree[0], it's faster for (l=length-1;l>=0;--l) { // start from large z gem* p_gem=temp_array+l; int index=(int)(p_gem->crit*ACC); // find its place in x if (tree_check_after(tree, tree_length, index, (int)(p_gem->bbound*ACC_TR))) { // look at y tree_add_element(tree, tree_length, index, (int)(p_gem->bbound*ACC_TR)); } else { p_gem->grade=0; broken++; } } // all unnecessary gems destroyed free(tree); // free subpools_length[grd]=length-broken; subpools[grd]=malloc(subpools_length[grd]*sizeof(gem)); // pool init via broken index=0; for (l=0; l<length; ++l) { // copying to subpool if (temp_array[l].grade!=0) { subpools[grd][index]=temp_array[l]; index++; } } free(temp_array); // free } // subpool[grd] is now full } pool_length[i]=0; for (grd=0; grd<grade_max-1; ++grd) pool_length[i]+=subpools_length[grd]; pool[i]=malloc(pool_length[i]*sizeof(gem)); int place=0; for (grd=0;grd<grade_max-1;++grd) { // copying to pool for (j=0; j<subpools_length[grd]; ++j) { pool[i][place]=subpools[grd][j]; place++; } } for (grd=0;grd<grade_max-1;++grd) { // free free(temp_pools[grd]); free(subpools[grd]); } gems[i]=pool[i][0]; // choosing gem (criteria moved to more_power def) for (j=1;j<pool_length[i];++j) if (gem_more_powerful(pool[i][j],gems[i])) { gems[i]=pool[i][j]; } if (!(output_options & mask_quiet)) { printf("Value:\t%d\n",i+1); if (output_options & mask_info) printf("Growth:\t%f\n", log(gem_power(gems[i]))/log(i+1)); if (output_options & mask_debug) { printf("Raw:\t%d\n",comb_tot); printf("Pool:\t%d\n",pool_length[i]); } gem_print(gems+i); } } if (output_options & mask_quiet) { // outputs last if we never seen any printf("Value:\t%d\n",len); printf("Growth:\t%f\n", log(gem_power(gems[len-1]))/log(len)); if (output_options & mask_debug) printf("Pool:\t%d\n",pool_length[len-1]); gem_print(gems+len-1); } gem* gemf=gems+len-1; // gem that will be displayed if (output_options & mask_upto) { double best_growth=-INFINITY; int best_index=0; for (i=0; i<len; ++i) { if (log(gem_power(gems[i]))/log(i+1) > best_growth) { best_index=i; best_growth=log(gem_power(gems[i]))/log(i+1); } } printf("Best gem up to %d:\n\n", len); printf("Value:\t%d\n",best_index+1); printf("Growth:\t%f\n", best_growth); gem_print(gems+best_index); gemf = gems+best_index; } gem* gem_array; gem red; if (output_options & mask_red) { if (len < 3 || pool_zero!=2) printf("I could not add red!\n\n"); else { int value=gem_getvalue(gemf); gemf = gem_putred(pool[value-1], pool_length[value-1], value, &red, &gem_array, 0, 0); printf("Gem with red added:\n\n"); printf("Value:\t%d\n", value); // made to work well with -u printf("Growth:\t%f\n", log(gem_power(*gemf))/log(value)); gem_print(gemf); } } if (output_options & mask_parens) { printf("Compressed combining scheme:\n"); print_parens_compressed(gemf); printf("\n\n"); } if (output_options & mask_tree) { printf("Gem tree:\n"); print_tree(gemf, ""); printf("\n"); } if (output_options & mask_table) print_table(gems, len); if (output_options & mask_equations) { // it ruins gems, must be last printf("Equations:\n"); print_equations(gemf); printf("\n"); } for (i=0;i<len;++i) free(pool[i]); // free if (output_options & mask_red && len > 2 && pool_zero==2) { free(gem_array); } }
static void zynq_init(MachineState *machine) { ram_addr_t ram_size = machine->ram_size; const char *cpu_model = machine->cpu_model; const char *kernel_filename = machine->kernel_filename; const char *kernel_cmdline = machine->kernel_cmdline; const char *initrd_filename = machine->initrd_filename; A9MPPrivState *mpcore; ObjectClass *cpu_oc; ARMCPU *cpu[MAX_CPUS]; MemoryRegion *address_space_mem = get_system_memory(); MemoryRegion *ext_ram = g_new(MemoryRegion, 1); MemoryRegion *ocm_ram = g_new(MemoryRegion, 1); DeviceState *dev; SysBusDevice *busdev; qemu_irq pic[64]; Error *err = NULL; int n; if (machine->cpu_model) { error_report("Zynq does not support CPU model override!\n"); exit(1); } if (!cpu_model) { cpu_model = "cortex-a9"; } cpu_oc = cpu_class_by_name(TYPE_ARM_CPU, cpu_model); for (n = 0; n < smp_cpus; n++) { cpu[n] = ARM_CPU(object_new(object_class_get_name(cpu_oc))); /* By default A9 CPUs have EL3 enabled. This board does not * currently support EL3 so the CPU EL3 property is disabled before * realization. */ if (object_property_find(OBJECT(cpu[n]), "has_el3", NULL)) { object_property_set_bool(OBJECT(cpu[n]), false, "has_el3", &err); if (err) { error_report("%s", error_get_pretty(err)); exit(1); } } object_property_set_int(OBJECT(cpu[n]), ZYNQ_BOARD_MIDR, "midr", &err); if (err) { error_report("%s", error_get_pretty(err)); exit(1); } object_property_set_int(OBJECT(cpu[n]), MPCORE_PERIPHBASE, "reset-cbar", &err); if (err) { error_report("%s", error_get_pretty(err)); exit(1); } object_property_set_bool(OBJECT(cpu[n]), true, "realized", &err); if (err) { error_report("%s", error_get_pretty(err)); exit(1); } } /* max 2GB ram */ if (ram_size > 0x80000000) { ram_size = 0x80000000; } /* pl353 */ dev = qdev_create(NULL, "arm.pl35x"); /* FIXME: handle this somewhere central */ object_property_add_child(container_get(qdev_get_machine(), "/unattached"), "pl353", OBJECT(dev), NULL); qdev_prop_set_uint8(dev, "x", 3); { DriveInfo *dinfo = drive_get_next(IF_PFLASH); BlockBackend *blk = dinfo ? blk_by_legacy_dinfo(dinfo) : NULL; DeviceState *att_dev = qdev_create(NULL, "cfi.pflash02"); Error *errp = NULL; if (blk && qdev_prop_set_drive(att_dev, "drive", blk)) { abort(); } qdev_prop_set_uint32(att_dev, "num-blocks", FLASH_SIZE/FLASH_SECTOR_SIZE); qdev_prop_set_uint32(att_dev, "sector-length", FLASH_SECTOR_SIZE); qdev_prop_set_uint8(att_dev, "width", 1); qdev_prop_set_uint8(att_dev, "mappings", 1); qdev_prop_set_uint8(att_dev, "big-endian", 0); qdev_prop_set_uint16(att_dev, "id0", 0x0066); qdev_prop_set_uint16(att_dev, "id1", 0x0022); qdev_prop_set_uint16(att_dev, "id2", 0x0000); qdev_prop_set_uint16(att_dev, "id3", 0x0000); qdev_prop_set_uint16(att_dev, "unlock-addr0", 0x0aaa); qdev_prop_set_uint16(att_dev, "unlock-addr1", 0x0555); qdev_prop_set_string(att_dev, "name", "pl353.pflash"); qdev_init_nofail(att_dev); object_property_set_link(OBJECT(dev), OBJECT(att_dev), "dev0", &errp); if (err) { error_report("%s", error_get_pretty(err)); exit(1); } dinfo = drive_get_next(IF_PFLASH); att_dev = nand_init(dinfo ? blk_by_legacy_dinfo(dinfo) : NULL, NAND_MFR_STMICRO, 0xaa); object_property_set_link(OBJECT(dev), OBJECT(att_dev), "dev1", &errp); if (err) { error_report("%s", error_get_pretty(err)); exit(1); } } qdev_init_nofail(dev); busdev = SYS_BUS_DEVICE(dev); sysbus_mmio_map(busdev, 0, 0xe000e000); sysbus_mmio_map(busdev, 1, 0xe2000000); sysbus_mmio_map(busdev, 2, 0xe1000000); /* DDR remapped to address zero. */ memory_region_allocate_system_memory(ext_ram, NULL, "zynq.ext_ram", ram_size); memory_region_add_subregion(address_space_mem, 0, ext_ram); /* 256K of on-chip memory */ memory_region_init_ram(ocm_ram, NULL, "zynq.ocm_ram", 256 << 10, &error_abort); vmstate_register_ram_global(ocm_ram); memory_region_add_subregion(address_space_mem, OCM_BASE, ocm_ram); DriveInfo *dinfo = drive_get(IF_PFLASH, 0, 0); /* AMD */ pflash_cfi02_register(0xe2000000, NULL, "zynq.pflash", FLASH_SIZE, dinfo ? blk_by_legacy_dinfo(dinfo) : NULL, FLASH_SECTOR_SIZE, FLASH_SIZE/FLASH_SECTOR_SIZE, 1, 1, 0x0066, 0x0022, 0x0000, 0x0000, 0x0555, 0x2aa, 0); dev = qdev_create(NULL, "xilinx,zynq_slcr"); qdev_init_nofail(dev); sysbus_mmio_map(SYS_BUS_DEVICE(dev), 0, 0xF8000000); for (n = 0; n < smp_cpus; n++) { qdev_connect_gpio_out(dev, n, qdev_get_gpio_in(DEVICE(cpu[n]), 0)); } mpcore = A9MPCORE_PRIV(object_new("a9mpcore_priv")); qdev_prop_set_uint32(DEVICE(mpcore), "num-cpu", smp_cpus); object_property_set_bool(OBJECT(mpcore), true, "realized", &err); if (err != NULL) { error_report("Couldn't realize the Zynq A9MPCore: %s", error_get_pretty(err)); exit(1); } busdev = SYS_BUS_DEVICE(DEVICE(mpcore)); sysbus_mmio_map(busdev, 0, MPCORE_PERIPHBASE); for (n = 0; n < smp_cpus; n++) { sysbus_connect_irq(busdev, n, qdev_get_gpio_in(DEVICE(cpu[n]), ARM_CPU_IRQ)); } for (n = 0; n < 64; n++) { pic[n] = qdev_get_gpio_in(dev, n); } zynq_init_zc70x_i2c(0xE0004000, pic[57-IRQ_OFFSET]); zynq_init_zc70x_i2c(0xE0005000, pic[80-IRQ_OFFSET]); dev = qdev_create(NULL, "xlnx,ps7-usb"); qdev_init_nofail(dev); busdev = SYS_BUS_DEVICE(dev); sysbus_mmio_map(busdev, 0, 0xE0002000); sysbus_connect_irq(busdev, 0, pic[53-IRQ_OFFSET]); dev = qdev_create(NULL, "xlnx,ps7-usb"); busdev = SYS_BUS_DEVICE(dev); qdev_init_nofail(dev); sysbus_mmio_map(busdev, 0, 0xE0003000); sysbus_connect_irq(busdev, 0, pic[76-IRQ_OFFSET]); zynq_init_spi_flashes(0xE0006000, pic[58-IRQ_OFFSET], false); zynq_init_spi_flashes(0xE0007000, pic[81-IRQ_OFFSET], false); zynq_init_spi_flashes(0xE000D000, pic[51-IRQ_OFFSET], true); sysbus_create_simple("cadence_uart", 0xE0000000, pic[59-IRQ_OFFSET]); sysbus_create_simple("cadence_uart", 0xE0001000, pic[82-IRQ_OFFSET]); sysbus_create_varargs("cadence_ttc", 0xF8001000, pic[42-IRQ_OFFSET], pic[43-IRQ_OFFSET], pic[44-IRQ_OFFSET], NULL); sysbus_create_varargs("cadence_ttc", 0xF8002000, pic[69-IRQ_OFFSET], pic[70-IRQ_OFFSET], pic[71-IRQ_OFFSET], NULL); gem_init(&nd_table[0], 0xE000B000, pic[54-IRQ_OFFSET]); gem_init(&nd_table[1], 0xE000C000, pic[77-IRQ_OFFSET]); dev = qdev_create(NULL, "generic-sdhci"); qdev_init_nofail(dev); sysbus_mmio_map(SYS_BUS_DEVICE(dev), 0, 0xE0100000); sysbus_connect_irq(SYS_BUS_DEVICE(dev), 0, pic[56-IRQ_OFFSET]); dev = qdev_create(NULL, "generic-sdhci"); qdev_init_nofail(dev); sysbus_mmio_map(SYS_BUS_DEVICE(dev), 0, 0xE0101000); sysbus_connect_irq(SYS_BUS_DEVICE(dev), 0, pic[79-IRQ_OFFSET]); dev = qdev_create(NULL, TYPE_ZYNQ_XADC); qdev_init_nofail(dev); sysbus_mmio_map(SYS_BUS_DEVICE(dev), 0, 0xF8007100); sysbus_connect_irq(SYS_BUS_DEVICE(dev), 0, pic[39-IRQ_OFFSET]); dev = qdev_create(NULL, "pl330"); qdev_prop_set_uint8(dev, "num_chnls", 8); qdev_prop_set_uint8(dev, "num_periph_req", 4); qdev_prop_set_uint8(dev, "num_events", 16); qdev_prop_set_uint8(dev, "data_width", 64); qdev_prop_set_uint8(dev, "wr_cap", 8); qdev_prop_set_uint8(dev, "wr_q_dep", 16); qdev_prop_set_uint8(dev, "rd_cap", 8); qdev_prop_set_uint8(dev, "rd_q_dep", 16); qdev_prop_set_uint16(dev, "data_buffer_dep", 256); qdev_init_nofail(dev); busdev = SYS_BUS_DEVICE(dev); sysbus_mmio_map(busdev, 0, 0xF8003000); sysbus_connect_irq(busdev, 0, pic[45-IRQ_OFFSET]); /* abort irq line */ for (n = 0; n < 8; ++n) { /* event irqs */ sysbus_connect_irq(busdev, n + 1, pic[dma_irqs[n] - IRQ_OFFSET]); } dev = qdev_create(NULL, "xlnx.ps7-dev-cfg"); object_property_add_child(qdev_get_machine(), "xilinx-devcfg", OBJECT(dev), NULL); qdev_init_nofail(dev); busdev = SYS_BUS_DEVICE(dev); sysbus_connect_irq(busdev, 0, pic[40-IRQ_OFFSET]); sysbus_mmio_map(busdev, 0, 0xF8007000); zynq_binfo.ram_size = ram_size; zynq_binfo.kernel_filename = kernel_filename; zynq_binfo.kernel_cmdline = kernel_cmdline; zynq_binfo.initrd_filename = initrd_filename; zynq_binfo.nb_cpus = smp_cpus; zynq_binfo.write_secondary_boot = zynq_write_secondary_boot; zynq_binfo.secondary_cpu_reset_hook = zynq_reset_secondary; zynq_binfo.smp_loader_start = SMP_BOOT_ADDR; zynq_binfo.board_id = 0xd32; zynq_binfo.loader_start = 0; arm_load_kernel(ARM_CPU(first_cpu), &zynq_binfo); }
void worker(int len, int output_options, int pool_zero, char* filename) { FILE* table=file_check(filename); // file is open to read if (table==NULL) exit(1); // if the file is not good we exit int i; gem* gems=malloc(len*sizeof(gem)); // if not malloc-ed 230k is the limit gem** pool=malloc(len*sizeof(gem*)); int* pool_length=malloc(len*sizeof(int)); pool[0]=malloc(pool_zero*sizeof(gem)); pool_length[0]=pool_zero; if (pool_zero==1) { // combine gem_init(pool[0],1,1,1,1); // start gem does not matter gem_init(gems ,1,1,1,1); // grade damage crit bbound } else { // spec gem_init(pool[0] ,1,DAMAGE_CRIT ,1,0); gem_init(pool[0]+1,1,DAMAGE_BBOUND,0,1); // BB has more dmg gem_init(gems ,1,DAMAGE_CRIT ,1,0); // grade damage crit bbound } int prevmax=pool_from_table(pool, pool_length, len, table); // pool filling fclose(table); // close if (prevmax<len-1) { for (i=0;i<=prevmax;++i) free(pool[i]); // free free(pool); // free free(pool_length); // free free(gems); // free if (prevmax>0) printf("Table stops at %d, not %d\n",prevmax+1,len); exit(1); } int skip_computations = (output_options & mask_quiet) && !((output_options & mask_table) || (output_options & mask_upto)); int first = skip_computations ? len-1 : 0; for (i=first; i<len; ++i) { gems[i]=pool[i][0]; for (int j=1; j<pool_length[i]; ++j) { if (gem_more_powerful(pool[i][j],gems[i])) { gems[i]=pool[i][j]; } } if (!(output_options & mask_quiet)) { printf("Value:\t%d\n",i+1); if (output_options & mask_info) printf("Growth:\t%f\n", log(gem_power(gems[i]))/log(i+1)); if (output_options & mask_debug) printf("Pool:\t%d\n",pool_length[i]); gem_print(gems+i); } } if (output_options & mask_quiet) { // outputs last if we never seen any printf("Value:\t%d\n",len); printf("Growth:\t%f\n", log(gem_power(gems[len-1]))/log(len)); if (output_options & mask_debug) printf("Pool:\t%d\n",pool_length[len-1]); gem_print(gems+len-1); } gem* gemf=gems+len-1; // gem that will be displayed if (output_options & mask_upto) { double best_growth=-INFINITY; int best_index=0; for (i=0; i<len; ++i) { if (log(gem_power(gems[i]))/log(i+1) > best_growth) { best_index=i; best_growth=log(gem_power(gems[i]))/log(i+1); } } printf("Best gem up to %d:\n\n", len); printf("Value:\t%d\n",best_index+1); printf("Growth:\t%f\n", best_growth); gem_print(gems+best_index); gemf = gems+best_index; } gem* gem_array = NULL; gem red; if (output_options & mask_red) { if (len < 3 || pool_zero!=2) printf("I could not add red!\n\n"); else { int value=gem_getvalue(gemf); gemf = gem_putred(pool[value-1], pool_length[value-1], value, &red, &gem_array, 0, 0); printf("Gem with red added:\n\n"); printf("Value:\t%d\n", value); // made to work well with -u printf("Growth:\t%f\n", log(gem_power(*gemf))/log(value)); gem_print(gemf); } } if (output_options & mask_parens) { printf("Compressed combining scheme:\n"); print_parens_compressed(gemf); printf("\n\n"); } if (output_options & mask_tree) { printf("Gem tree:\n"); print_tree(gemf, ""); printf("\n"); } if (output_options & mask_table) print_table(gems, len); if (output_options & mask_equations) { // it ruins gems, must be last printf("Equations:\n"); print_equations(gemf); printf("\n"); } for (i=0;i<len;++i) free(pool[i]); // free free(pool); free(pool_length); free(gems); if (output_options & mask_red && len > 2 && pool_zero==2) { free(gem_array); } }
static void zynq_init(QEMUMachineInitArgs *args) { ram_addr_t ram_size = args->ram_size; const char *cpu_model = args->cpu_model; const char *kernel_filename = args->kernel_filename; const char *kernel_cmdline = args->kernel_cmdline; const char *initrd_filename = args->initrd_filename; ARMCPU *cpu; MemoryRegion *address_space_mem = get_system_memory(); MemoryRegion *ext_ram = g_new(MemoryRegion, 1); MemoryRegion *ocm_ram = g_new(MemoryRegion, 1); DeviceState *dev; SysBusDevice *busdev; qemu_irq pic[64]; NICInfo *nd; int n; if (!cpu_model) { cpu_model = "cortex-a9"; } cpu = cpu_arm_init(cpu_model); if (!cpu) { fprintf(stderr, "Unable to find CPU definition\n"); exit(1); } /* max 2GB ram */ if (ram_size > 0x80000000) { ram_size = 0x80000000; } /* DDR remapped to address zero. */ memory_region_init_ram(ext_ram, NULL, "zynq.ext_ram", ram_size); vmstate_register_ram_global(ext_ram); memory_region_add_subregion(address_space_mem, 0, ext_ram); /* 256K of on-chip memory */ memory_region_init_ram(ocm_ram, NULL, "zynq.ocm_ram", 256 << 10); vmstate_register_ram_global(ocm_ram); memory_region_add_subregion(address_space_mem, 0xFFFC0000, ocm_ram); DriveInfo *dinfo = drive_get(IF_PFLASH, 0, 0); /* AMD */ pflash_cfi02_register(0xe2000000, NULL, "zynq.pflash", FLASH_SIZE, dinfo ? dinfo->bdrv : NULL, FLASH_SECTOR_SIZE, FLASH_SIZE/FLASH_SECTOR_SIZE, 1, 1, 0x0066, 0x0022, 0x0000, 0x0000, 0x0555, 0x2aa, 0); dev = qdev_create(NULL, "xilinx,zynq_slcr"); qdev_init_nofail(dev); sysbus_mmio_map(SYS_BUS_DEVICE(dev), 0, 0xF8000000); dev = qdev_create(NULL, "a9mpcore_priv"); qdev_prop_set_uint32(dev, "num-cpu", 1); qdev_init_nofail(dev); busdev = SYS_BUS_DEVICE(dev); sysbus_mmio_map(busdev, 0, 0xF8F00000); sysbus_connect_irq(busdev, 0, qdev_get_gpio_in(DEVICE(cpu), ARM_CPU_IRQ)); for (n = 0; n < 64; n++) { pic[n] = qdev_get_gpio_in(dev, n); } zynq_init_spi_flashes(0xE0006000, pic[58-IRQ_OFFSET], false); zynq_init_spi_flashes(0xE0007000, pic[81-IRQ_OFFSET], false); zynq_init_spi_flashes(0xE000D000, pic[51-IRQ_OFFSET], true); sysbus_create_simple("xlnx,ps7-usb", 0xE0002000, pic[53-IRQ_OFFSET]); sysbus_create_simple("xlnx,ps7-usb", 0xE0003000, pic[76-IRQ_OFFSET]); sysbus_create_simple("cadence_uart", 0xE0000000, pic[59-IRQ_OFFSET]); sysbus_create_simple("cadence_uart", 0xE0001000, pic[82-IRQ_OFFSET]); sysbus_create_varargs("cadence_ttc", 0xF8001000, pic[42-IRQ_OFFSET], pic[43-IRQ_OFFSET], pic[44-IRQ_OFFSET], NULL); sysbus_create_varargs("cadence_ttc", 0xF8002000, pic[69-IRQ_OFFSET], pic[70-IRQ_OFFSET], pic[71-IRQ_OFFSET], NULL); for (n = 0; n < nb_nics; n++) { nd = &nd_table[n]; if (n == 0) { gem_init(nd, 0xE000B000, pic[54-IRQ_OFFSET]); } else if (n == 1) { gem_init(nd, 0xE000C000, pic[77-IRQ_OFFSET]); } } dev = qdev_create(NULL, "generic-sdhci"); qdev_init_nofail(dev); sysbus_mmio_map(SYS_BUS_DEVICE(dev), 0, 0xE0100000); sysbus_connect_irq(SYS_BUS_DEVICE(dev), 0, pic[56-IRQ_OFFSET]); dev = qdev_create(NULL, "generic-sdhci"); qdev_init_nofail(dev); sysbus_mmio_map(SYS_BUS_DEVICE(dev), 0, 0xE0101000); sysbus_connect_irq(SYS_BUS_DEVICE(dev), 0, pic[79-IRQ_OFFSET]); dev = qdev_create(NULL, "pl330"); qdev_prop_set_uint8(dev, "num_chnls", 8); qdev_prop_set_uint8(dev, "num_periph_req", 4); qdev_prop_set_uint8(dev, "num_events", 16); qdev_prop_set_uint8(dev, "data_width", 64); qdev_prop_set_uint8(dev, "wr_cap", 8); qdev_prop_set_uint8(dev, "wr_q_dep", 16); qdev_prop_set_uint8(dev, "rd_cap", 8); qdev_prop_set_uint8(dev, "rd_q_dep", 16); qdev_prop_set_uint16(dev, "data_buffer_dep", 256); qdev_init_nofail(dev); busdev = SYS_BUS_DEVICE(dev); sysbus_mmio_map(busdev, 0, 0xF8003000); sysbus_connect_irq(busdev, 0, pic[45-IRQ_OFFSET]); /* abort irq line */ for (n = 0; n < 8; ++n) { /* event irqs */ sysbus_connect_irq(busdev, n + 1, pic[dma_irqs[n] - IRQ_OFFSET]); } zynq_binfo.ram_size = ram_size; zynq_binfo.kernel_filename = kernel_filename; zynq_binfo.kernel_cmdline = kernel_cmdline; zynq_binfo.initrd_filename = initrd_filename; zynq_binfo.nb_cpus = 1; zynq_binfo.board_id = 0xd32; zynq_binfo.loader_start = 0; arm_load_kernel(ARM_CPU(first_cpu), &zynq_binfo); }
void target_init(void) { gem_init(GEM0_BASE); }
void worker(int len, int output_options, int gem_limit, char* filename, char* filenameA, int TC, int As, int Namps) { FILE* table=file_check(filename); // file is open to read if (table==NULL) exit(1); // if the file is not good we exit int i; gem* pool[len]; int pool_length[len]; pool[0]=malloc(2*sizeof(gem)); pool_length[0]=2; gem_init(pool[0] ,1,1.000000,1,0); // grade damage crit bbound gem_init(pool[0]+1,1,1.186168,0,1); // BB has more dmg int prevmax=pool_from_table(pool, pool_length, gem_limit, table); // killgem pool filling fclose(table); if (prevmax<len-1) { // if the killgems are not enough for (i=prevmax+1; i<len; ++i) { pool_length[i]=0; pool[i]=NULL; } } gem* poolf[len]; int poolf_length[len]; KGSPEC_COMPRESSION printf("Gem speccing pool compression done!\n"); FILE* tableA=file_check(filenameA); // fileA is open to read if (tableA==NULL) exit(1); // if the file is not good we exit int lena = Namps ? len/Namps : 1; // if Namps==0 let lena=1 gemY* poolY[lena]; int poolY_length[lena]; poolY[0]=malloc(sizeof(gemY)); poolY_length[0]=1; gem_init_Y(poolY[0],1,1,1); int prevmaxA=pool_from_table_Y(poolY, poolY_length, lena, tableA); // amps pool filling fclose(tableA); if (prevmaxA<lena-1) { for (i=0;i<=prevmaxA;++i) free(poolY[i]); // free if (prevmaxA>0) printf("Amp table stops at %d, not %d\n",prevmaxA+1,lena); exit(1); } gemY* poolYf[lena]; int poolYf_length[lena]; AMPS_COMPRESSION printf("Amp pool compression done!\n\n"); int j,k,h; // let's choose the right gem-amp combo gem gems[len]; gemY amps[len]; gem_init(gems,1,1,1,0); amps[0]=(gemY){0}; double crit_ratio =Namps*(0.15+As/3*0.004)*2*(1+0.03*TC)/(1.0+TC/3*0.1); double damage_ratio=Namps*(0.20+As/3*0.004) * (1+0.03*TC)/(1.2+TC/3*0.1); if (!(output_options & mask_quiet)) { printf("Total value:\t1\n\n"); printf("Killgem\n"); gem_print(gems); printf("Amplifier (x%d)\n", Namps); gem_print_Y(amps); } for (i=1;i<len;++i) { // for every total value gems[i]=(gem){0}; // we init the gems amps[i]=(gemY){0}; // to extremely weak ones for (k=0;k<poolf_length[i];++k) { // first we compare the gem alone if (gem_power(poolf[i][k]) > gem_power(gems[i])) { gems[i]=poolf[i][k]; } } double power = gem_power(gems[i]); if (Namps!=0) for (j=1;j<=i/Namps;++j) { // for every amount of amps we can fit in int value = i-Namps*j; // this is the amount of gems we have left for (k=0;k<poolf_length[value];++k) { // we search in that pool for (h=0;h<poolYf_length[j-1];++h) { // and we look in the amp pool if (gem_amp_power(poolf[value][k], poolYf[j-1][h], damage_ratio, crit_ratio) > power) { power = gem_amp_power(poolf[value][k], poolYf[j-1][h], damage_ratio, crit_ratio); gems[i]=poolf[value][k]; amps[i]=poolYf[j-1][h]; } } } } if (!(output_options & mask_quiet)) { printf("Total value:\t%d\n\n", i+1); if (prevmax<len-1) printf("Killgem limit:\t%d\n", prevmax+1); printf("Killgem\n"); printf("Value:\t%d\n",gem_getvalue(gems+i)); if (output_options & mask_debug) printf("Pool:\t%d\n",poolf_length[gem_getvalue(gems+i)-1]); gem_print(gems+i); printf("Amplifier (x%d)\n", Namps); printf("Value:\t%d\n",gem_getvalue_Y(amps+i)); if (output_options & mask_debug) printf("Pool:\t%d\n",poolYf_length[gem_getvalue_Y(amps+i)-1]); gem_print_Y(amps+i); printf("Spec base power: \t%#.7g\n\n", gem_amp_power(gems[i], amps[i], damage_ratio, crit_ratio)); } } if (output_options & mask_quiet) { // outputs last if we never seen any printf("Total value:\t%d\n\n", len); if (prevmax<len-1) printf("Killgem limit:\t%d\n", prevmax+1); printf("Killgem\n"); printf("Value:\t%d\n", gem_getvalue(gems+len-1)); gem_print(gems+len-1); printf("Amplifier (x%d)\n", Namps); printf("Value:\t%d\n", gem_getvalue_Y(amps+len-1)); gem_print_Y(amps+len-1); printf("Spec base power: \t%#.7g\n\n", gem_amp_power(gems[len-1], amps[len-1], damage_ratio, crit_ratio)); } gem* gemf=gems+len-1; // gem that will be displayed gemY* ampf=amps+len-1; // amp that will be displayed gem* gem_array; gem red; if (output_options & mask_red) { if (len < 3) printf("I could not add red!\n\n"); else { int value=gem_getvalue(gemf); gemf = gem_putred(poolf[value-1], poolf_length[value-1], value, &red, &gem_array, damage_ratio*ampf->damage, crit_ratio*ampf->crit); printf("Setup with red added:\n\n"); printf("Total value:\t%d\n\n", value+Namps*gem_getvalue_Y(ampf)); printf("Killgem\n"); printf("Value:\t%d\n", value); gem_print(gemf); printf("Amplifier (x%d)\n", Namps); printf("Value:\t%d\n", gem_getvalue_Y(ampf)); gem_print_Y(ampf); printf("Spec base power with red:\t%#.7g\n\n", gem_amp_power(*gemf, *ampf, damage_ratio, crit_ratio)); } } if (output_options & mask_parens) { printf("Killgem speccing scheme:\n"); print_parens_compressed(gemf); printf("\n\n"); printf("Amplifier speccing scheme:\n"); print_parens_compressed_Y(ampf); printf("\n\n"); } if (output_options & mask_tree) { printf("Killgem tree:\n"); print_tree(gemf, ""); printf("\n"); printf("Amplifier tree:\n"); print_tree_Y(ampf, ""); printf("\n"); } if (output_options & mask_table) print_ngems_table(gems, amps, damage_ratio, crit_ratio, len); if (output_options & mask_equations) { // it ruins gems, must be last printf("Killgem equations:\n"); print_equations(gemf); printf("\n"); printf("Amplifier equations:\n"); print_equations_Y(ampf); printf("\n"); } for (i=0;i<len;++i) free(pool[i]); // free gems for (i=0;i<len;++i) free(poolf[i]); // free gems compressed for (i=0;i<lena;++i) free(poolY[i]); // free amps for (i=0;i<lena;++i) free(poolYf[i]); // free amps compressed if (output_options & mask_red && len > 2) { free(gem_array); } }
void worker(int len, int output_options) { printf("\n"); int i; gem* gems=malloc(len*sizeof(gem)); // if not malloc-ed 230k is the limit gem* pool[len]; int pool_length[len]; pool[0]=malloc(sizeof(gem)); gem_init(gems,1,1); gem_init(pool[0],1,1); pool_length[0]=1; if (!(output_options & mask_quiet)) gem_print(gems); for (i=1; i<len; ++i) { int j,k,h; const int eoc=(i+1)/ (1+1); // end of combining const int j0 =(i+1)/(10+1); // value ratio < 10 int comb_tot=0; const int grade_max=(int)(log2(i+1)+1); // gems with max grade cannot be destroyed, so this is a max, not a sup gem temp_array[grade_max-1]; // this will have all the grades for (j=0; j<grade_max-1; ++j) temp_array[j]=(gem){0}; for (j=j0; j<eoc; ++j) { // combine gems and put them in temp array for (k=0; k< pool_length[j]; ++k) { int g1=(pool[j]+k)->grade; for (h=0; h< pool_length[i-1-j]; ++h) { int delta=g1 - (pool[i-1-j]+h)->grade; if (abs(delta)<=2) { // grade difference <= 2 comb_tot++; gem temp; gem_combine(pool[j]+k, pool[i-1-j]+h, &temp); int grd=temp.grade-2; if (gem_better(temp, temp_array[grd])) { temp_array[grd]=temp; } } } } } int gemNum=0; for (j=0; j<grade_max-1; ++j) if (temp_array[j].grade!=0) gemNum++; pool_length[i]=gemNum; pool[i]=malloc(pool_length[i]*sizeof(gem)); int place=0; for (j=0; j<grade_max-1; ++j) { // copying to pool if (temp_array[j].grade!=0) { pool[i][place]=temp_array[j]; place++; } } gems[i]=pool[i][0]; for (j=1;j<pool_length[i];++j) if (gem_better(pool[i][j],gems[i])) { gems[i]=pool[i][j]; } if (!(output_options & mask_quiet)) { printf("Value:\t%d\n",i+1); if (output_options & mask_info) printf("Growth:\t%f\n", log(gem_power(gems[i]))/log(i+1)); if (output_options & mask_debug) { printf("Raw:\t%d\n",comb_tot); printf("Pool:\t%d\n",pool_length[i]); } gem_print(gems+i); } } if (output_options & mask_quiet) { // outputs last if we never seen any printf("Value:\t%d\n",len); printf("Growth:\t%f\n", log(gem_power(gems[len-1]))/log(len)); if (output_options & mask_debug) printf("Pool:\t%d\n",pool_length[len-1]); gem_print(gems+len-1); } gem* gemf=gems+len-1; // gem that will be displayed if (output_options & mask_upto) { double best_growth=-INFINITY; int best_index=0; for (i=0; i<len; ++i) { if (log(gem_power(gems[i]))/log(i+1) > best_growth) { best_index=i; best_growth=log(gem_power(gems[i]))/log(i+1); } } printf("Best gem up to %d:\n\n", len); printf("Value:\t%d\n",best_index+1); printf("Growth:\t%f\n", best_growth); gem_print(gems+best_index); gemf = gems+best_index; } gem* gem_array; gem red; if (output_options & mask_red) { if (len < 2) printf("I could not add red!\n\n"); else { int value=gem_getvalue(gemf); gemf = gem_putred(pool[value-1], pool_length[value-1], value, &red, &gem_array); printf("Gem with red added:\n\n"); printf("Value:\t%d\n", value); // made to work well with -u printf("Growth:\t%f\n", log(gem_power(*gemf))/log(value)); gem_print(gemf); } } if (output_options & mask_parens) { printf("Compressed combining scheme:\n"); print_parens_compressed(gemf); printf("\n\n"); } if (output_options & mask_tree) { printf("Gem tree:\n"); print_tree(gemf, ""); printf("\n"); } if (output_options & mask_table) print_table(gems, len); if (output_options & mask_equations) { // it ruins gems, must be last printf("Equations:\n"); print_equations(gemf); printf("\n"); } for (i=0;i<len;++i) free(pool[i]); // free free(gems); if (output_options & mask_red && len > 1) { free(gem_array); } }
void worker(int len, int output_options, char* filename) { FILE* table=file_check(filename); // file is open to read if (table==NULL) exit(1); // if the file is not good we exit int i; gem* gems=malloc(len*sizeof(gem)); // if not malloc-ed 230k is the limit gem* pool[len]; int pool_length[len]; pool[0]=malloc(sizeof(gem)); gem_init(gems,1,1,1); gem_init(pool[0],1,1,1); pool_length[0]=1; int prevmax=pool_from_table(pool, pool_length, len, table); // pool filling fclose(table); // close if (prevmax<len-1) { for (i=0;i<=prevmax;++i) free(pool[i]); // free free(gems); // free if (prevmax>0) printf("Table stops at %d, not %d\n",prevmax+1,len); exit(1); } if (!(output_options & mask_quiet)) gem_print(gems); for (i=1;i<len;++i) { int j; gems[i]=pool[i][0]; for (j=1;j<pool_length[i];++j) if (gem_more_powerful(pool[i][j],gems[i])) { gems[i]=pool[i][j]; } if (!(output_options & mask_quiet)) { printf("Value:\t%d\n",i+1); if (output_options & mask_info) printf("Growth:\t%f\n", log(gem_power(gems[i]))/log(i+1)); if (output_options & mask_debug) printf("Pool:\t%d\n",pool_length[i]); gem_print(gems+i); } } if (output_options & mask_quiet) { // outputs last if we never seen any printf("Value:\t%d\n",len); printf("Growth:\t%f\n", log(gem_power(gems[len-1]))/log(len)); if (output_options & mask_debug) printf("Pool:\t%d\n",pool_length[len-1]); gem_print(gems+len-1); } gem* gemf=gems+len-1; // gem that will be displayed if (output_options & mask_upto) { double best_growth=-INFINITY; int best_index=0; for (i=0; i<len; ++i) { if (log(gem_power(gems[i]))/log(i+1) > best_growth) { best_index=i; best_growth=log(gem_power(gems[i]))/log(i+1); } } printf("Best gem up to %d:\n\n", len); printf("Value:\t%d\n",best_index+1); printf("Growth:\t%f\n", best_growth); gem_print(gems+best_index); gemf = gems+best_index; } gem* gem_array; gem red; if (output_options & mask_red) { if (len < 2) printf("I could not add red!\n\n"); else { int value=gem_getvalue(gemf); gemf = gem_putred(pool[value-1], pool_length[value-1], value, &red, &gem_array); printf("Gem with red added:\n\n"); printf("Value:\t%d\n", value); // made to work well with -u printf("Growth:\t%f\n", log(gem_power(*gemf))/log(value)); gem_print(gemf); } } if (output_options & mask_parens) { printf("Compressed combining scheme:\n"); print_parens_compressed(gemf); printf("\n\n"); } if (output_options & mask_tree) { printf("Gem tree:\n"); print_tree(gemf, ""); printf("\n"); } if (output_options & mask_table) print_table(gems, len); if (output_options & mask_equations) { // it ruins gems, must be last printf("Equations:\n"); print_equations(gemf); printf("\n"); } for (i=0;i<len;++i) free(pool[i]); // free free(gems); // free if (output_options & mask_red && len > 1) { free(gem_array); } }
void worker(int len, int output_options, int pool_zero, char* filename) { FILE* table=table_init(filename, pool_zero); // init killgem int i; int size; gem* pool[len]; int pool_length[len]; pool[0]=malloc(pool_zero*sizeof(gem)); pool_length[0]=pool_zero; if (pool_zero==1) { // combine gem_init(pool[0],1,1,1,1); // start gem does not matter size=1000; // reasonable comb sizing } else { // spec gem_init(pool[0] ,1,1.000000,1,0); gem_init(pool[0]+1,1,1.186168,0,1); // BB has more dmg size=20000; // reasonable spec sizing } int prevmax=pool_from_table(pool, pool_length, len, table); // pool filling if (prevmax+1==len) { fclose(table); for (i=0;i<len;++i) free(pool[i]); // free printf("Table is longer than %d, no need to do anything\n\n",prevmax+1); exit(1); } table=freopen(filename,"a", table); // append -> updating possible for (i=prevmax+1; i<len; ++i) { int j,k,h,l; const int eoc=(i+1)/ (1+1); // end of combining const int j0 =(i+1)/(10+1); // value ratio < 10 int comb_tot=0; int grade_max=(int)(log2(i+1)+1); // gems with max grade cannot be destroyed, so this is a max, not a sup gem* temp_pools[grade_max-1]; // get the temp pools for every grade int temp_index[grade_max-1]; // index of work point in temp pools gem* subpools[grade_max-1]; // get subpools for every grade int subpools_length[grade_max-1]; for (j=0; j<grade_max-1; ++j) { // init everything temp_pools[j]=malloc(size*sizeof(gem)); temp_index[j]=0; subpools[j]=NULL; // just to be able to free it subpools_length[j]=0; } for (j=j0; j<eoc; ++j) { // combine gems and put them in temp array for (k=0; k< pool_length[j]; ++k) { int g1=(pool[j]+k)->grade; for (h=0; h< pool_length[i-1-j]; ++h) { int delta=g1 - (pool[i-1-j]+h)->grade; if (abs(delta)<=2) { // grade difference <= 2 comb_tot++; gem temp; gem_combine(pool[j]+k, pool[i-1-j]+h, &temp); int grd=temp.grade-2; temp_pools[grd][temp_index[grd]]=temp; temp_index[grd]++; if (temp_index[grd]==size) { // let's skim a pool int length=size+subpools_length[grd]; gem* temp_array=malloc(length*sizeof(gem)); int index=0; for (l=0; l<size; ++l) { // copy new gems temp_array[index]=temp_pools[grd][l]; index++; } temp_index[grd]=0; // temp index reset for (l=0; l<subpools_length[grd]; ++l) { // copy old gems temp_array[index]=subpools[grd][l]; index++; } free(subpools[grd]); // free gem_sort_crit(temp_array,length); // work starts float lastcrit=-1; int tree_cell=0; for (int l=0; l<length; ++l) { if (temp_array[l].crit == lastcrit) temp_array[l].place=tree_cell-1; else { temp_array[l].place=tree_cell++; lastcrit = temp_array[l].crit; } } gem_sort_exact(temp_array,length); int broken=0; int tree_length= 1 << (int)ceil(log2(tree_cell)); // this is pow(2, ceil()) bitwise for speed improvement float* tree=malloc((tree_length*2)*sizeof(float)); for (l=0; l<tree_length*2; ++l) tree[l]=-1; // init also tree[0], it's faster for (l=length-1;l>=0;--l) { // start from large z gem* p_gem=temp_array+l; if (ftree_check_after(tree, tree_length, p_gem->place, p_gem->bbound)) { ftree_add_element(tree, tree_length, p_gem->place, p_gem->bbound); } else { p_gem->grade=0; broken++; } } // all unnecessary gems destroyed free(tree); // free subpools_length[grd]=length-broken; subpools[grd]=malloc(subpools_length[grd]*sizeof(gem)); // pool init via broken index=0; for (l=0; l<length; ++l) { // copying to subpool if (temp_array[l].grade!=0) { subpools[grd][index]=temp_array[l]; index++; } } free(temp_array); // free } // rebuilt subpool[grd], work restarts } } } } int grd; for (grd=0; grd<grade_max-1; ++grd) { // let's put remaining gems on if (temp_index[grd] != 0) { int length=temp_index[grd]+subpools_length[grd]; gem* temp_array=malloc(length*sizeof(gem)); int index=0; for (l=0; l<temp_index[grd]; ++l) { // copy new gems temp_array[index]=temp_pools[grd][l]; index++; } for (l=0; l<subpools_length[grd]; ++l) { // copy old gems temp_array[index]=subpools[grd][l]; index++; } free(subpools[grd]); // free gem_sort_crit(temp_array,length); // work starts float lastcrit=-1; int tree_cell=0; for (int l=0; l<length; ++l) { if (temp_array[l].crit == lastcrit) temp_array[l].place=tree_cell-1; else { temp_array[l].place=tree_cell++; lastcrit = temp_array[l].crit; } } gem_sort_exact(temp_array,length); int broken=0; int tree_length= 1 << (int)ceil(log2(tree_cell)); // this is pow(2, ceil()) bitwise for speed improvement float* tree=malloc((tree_length*2)*sizeof(float)); for (l=0; l<tree_length*2; ++l) tree[l]=-1; // init also tree[0], it's faster for (l=length-1;l>=0;--l) { // start from large z gem* p_gem=temp_array+l; if (ftree_check_after(tree, tree_length, p_gem->place, p_gem->bbound)) { ftree_add_element(tree, tree_length, p_gem->place, p_gem->bbound); } else { p_gem->grade=0; broken++; } } // all unnecessary gems destroyed free(tree); // free subpools_length[grd]=length-broken; subpools[grd]=malloc(subpools_length[grd]*sizeof(gem)); // pool init via broken index=0; for (l=0; l<length; ++l) { // copying to subpool if (temp_array[l].grade!=0) { subpools[grd][index]=temp_array[l]; index++; } } free(temp_array); // free } // subpool[grd] is now full } pool_length[i]=0; for (grd=0; grd<grade_max-1; ++grd) pool_length[i]+=subpools_length[grd]; pool[i]=malloc(pool_length[i]*sizeof(gem)); int place=0; for (grd=0;grd<grade_max-1;++grd) { // copying to pool for (j=0; j<subpools_length[grd]; ++j) { pool[i][place]=subpools[grd][j]; place++; } } for (grd=0;grd<grade_max-1;++grd) { // free free(temp_pools[grd]); free(subpools[grd]); } if (!(output_options & mask_quiet)) { printf("Value:\t%d\n",i+1); if (output_options & mask_debug) { printf("Raw:\t%d\n",comb_tot); printf("Pool:\t%d\n\n",pool_length[i]); } } table_write_iteration(pool, pool_length, i, table); // write on file } fclose(table); // close for (i=0;i<len;++i) free(pool[i]); // free }
void worker(int len, int output_options, int pool_zero) { printf("\n"); int i; int size; gem gems[len]; gem* pool[len]; int pool_length[len]; pool[0]=malloc(pool_zero*sizeof(gem)); pool_length[0]=pool_zero; if (pool_zero==1) { // combine gem_init(pool[0],1,1,1); gem_init(gems ,1,1,1); size=100; // reasonable comb sizing } else { // spec gem_init(pool[0] ,1,1,0); gem_init(pool[0]+1,1,0,1); gem_init(gems ,1,1,0); size=2000; // reasonable spec sizing } if (!(output_options & mask_quiet)) gem_print(gems); for (i=1; i<len; ++i) { int j,k,h,l; const int eoc=(i+1)/ (1+1); // end of combining const int j0 =(i+1)/(10+1); // value ratio < 10 int comb_tot=0; const int grade_max=(int)(log2(i+1)+1); // gems with max grade cannot be destroyed, so this is a max, not a sup gem* temp_pools[grade_max-1]; // get the temp pools for every grade int temp_index[grade_max-1]; // index of work point in temp pools gem* subpools[grade_max-1]; // get subpools for every grade int subpools_length[grade_max-1]; for (j=0; j<grade_max-1; ++j) { // init everything temp_pools[j]=malloc(size*sizeof(gem)); temp_index[j]=0; subpools[j]=NULL; // just to be able to free it subpools_length[j]=0; } for (j=j0; j<eoc; ++j) { // combine gems and put them in temp array for (k=0; k< pool_length[j]; ++k) { int g1=(pool[j]+k)->grade; for (h=0; h< pool_length[i-1-j]; ++h) { int delta=g1 - (pool[i-1-j]+h)->grade; if (abs(delta)<=2) { // grade difference <= 2 comb_tot++; gem temp; gem_combine(pool[j]+k, pool[i-1-j]+h, &temp); int grd=temp.grade-2; temp_pools[grd][temp_index[grd]]=temp; temp_index[grd]++; if (temp_index[grd]==size) { // let's skim a pool int length=size+subpools_length[grd]; gem* temp_array=malloc(length*sizeof(gem)); int index=0; for (l=0; l<temp_index[grd]; ++l) { // copy new gems temp_array[index]=temp_pools[grd][l]; index++; } temp_index[grd]=0; // temp index reset for (l=0; l<subpools_length[grd]; ++l) { // copy old gems temp_array[index]=subpools[grd][l]; index++; } free(subpools[grd]); // free gem_sort(temp_array,length); // work starts int broken=0; float lim_bbound=-1; for (l=length-1;l>=0;--l) { if ((int)(ACC*temp_array[l].bbound)<=(int)(ACC*lim_bbound)) { temp_array[l].grade=0; broken++; } else lim_bbound=temp_array[l].bbound; } // all unnecessary gems destroyed subpools_length[grd]=length-broken; subpools[grd]=malloc(subpools_length[grd]*sizeof(gem)); // pool init via broken index=0; for (l=0; l<length; ++l) { // copying to subpool if (temp_array[l].grade!=0) { subpools[grd][index]=temp_array[l]; index++; } } free(temp_array); // free } // rebuilt subpool[grd], work restarts } } } } int grd; for (grd=0; grd<grade_max-1; ++grd) { // let's put remaining gems on if (temp_index[grd] != 0) { int length=temp_index[grd]+subpools_length[grd]; gem* temp_array=malloc(length*sizeof(gem)); int index=0; for (l=0; l<temp_index[grd]; ++l) { // copy new gems temp_array[index]=temp_pools[grd][l]; index++; } for (l=0; l<subpools_length[grd]; ++l) { // copy old gems temp_array[index]=subpools[grd][l]; index++; } free(subpools[grd]); // free gem_sort(temp_array,length); // work starts int broken=0; float lim_bbound=-1; for (l=length-1;l>=0;--l) { if ((int)(ACC*temp_array[l].bbound)<=(int)(ACC*lim_bbound)) { temp_array[l].grade=0; broken++; } else lim_bbound=temp_array[l].bbound; } // all unnecessary gems destroyed subpools_length[grd]=length-broken; subpools[grd]=malloc(subpools_length[grd]*sizeof(gem)); // pool init via broken index=0; for (l=0; l<length; ++l) { // copying to subpool if (temp_array[l].grade!=0) { subpools[grd][index]=temp_array[l]; index++; } } free(temp_array); // free } // subpool[grd] is now full } pool_length[i]=0; for (grd=0; grd<grade_max-1; ++grd) pool_length[i]+=subpools_length[grd]; pool[i]=malloc(pool_length[i]*sizeof(gem)); int place=0; for (grd=0;grd<grade_max-1;++grd) { // copying to pool for (j=0; j<subpools_length[grd]; ++j) { pool[i][place]=subpools[grd][j]; place++; } } for (grd=0;grd<grade_max-1;++grd) { // free free(temp_pools[grd]); free(subpools[grd]); } gems[i]=pool[i][0]; // choosing gem (criteria moved to more_power def) for (j=1;j<pool_length[i];++j) if (gem_more_powerful(pool[i][j],gems[i])) { gems[i]=pool[i][j]; } if (!(output_options & mask_quiet)) { printf("Value:\t%d\n",i+1); if (output_options & mask_info) printf("Growth:\t%f\n", log(gem_power(gems[i]))/log(i+1)); if (output_options & mask_debug) { printf("Raw:\t%d\n",comb_tot); printf("Pool:\t%d\n",pool_length[i]); } gem_print(gems+i); } } if (output_options & mask_quiet) { // outputs last if we never seen any printf("Value:\t%d\n",len); printf("Growth:\t%f\n", log(gem_power(gems[len-1]))/log(len)); if (output_options & mask_debug) printf("Pool:\t%d\n",pool_length[len-1]); gem_print(gems+len-1); } gem* gemf=gems+len-1; // gem that will be displayed if (output_options & mask_upto) { double best_growth=-INFINITY; int best_index=0; for (i=0; i<len; ++i) { if (log(gem_power(gems[i]))/log(i+1) > best_growth) { best_index=i; best_growth=log(gem_power(gems[i]))/log(i+1); } } printf("Best gem up to %d:\n\n", len); printf("Value:\t%d\n",best_index+1); printf("Growth:\t%f\n", best_growth); gem_print(gems+best_index); gemf = gems+best_index; } gem* gem_array = NULL; gem red; if (output_options & mask_red) { if (len < 3 || pool_zero!=2) printf("I could not add red!\n\n"); else { int value=gem_getvalue(gemf); gemf = gem_putred(pool[value-1], pool_length[value-1], value, &red, &gem_array, 0); printf("Gem with red added:\n\n"); printf("Value:\t%d\n", value); // made to work well with -u printf("Growth:\t%f\n", log(gem_power(*gemf))/log(value)); gem_print(gemf); } } if (output_options & mask_parens) { printf("Compressed combining scheme:\n"); print_parens_compressed(gemf); printf("\n\n"); } if (output_options & mask_tree) { printf("Gem tree:\n"); print_tree(gemf, ""); printf("\n"); } if (output_options & mask_table) print_table(gems, len); if (output_options & mask_equations) { // it ruins gems, must be last printf("Equations:\n"); print_equations(gemf); printf("\n"); } for (i=0;i<len;++i) free(pool[i]); // free if (output_options & mask_red && len > 2 && pool_zero==2) { free(gem_array); } }