示例#1
0
文件: rand.c 项目: 0x00evil/nmap
int
rand_shuffle(rand_t *r, void *base, size_t nmemb, size_t size)
{
	u_char *save, *src, *dst, *start = (u_char *)base;
	u_int i, j;

	if (nmemb < 2)
		return (0);
	
	if ((u_int)r->tmplen < size) {
		if (r->tmp == NULL) {
			if ((save = malloc(size)) == NULL)
				return (-1);
		} else if ((save = realloc(r->tmp, size)) == NULL)
			return (-1);
		
		r->tmp = save;
		r->tmplen = size;
	} else
		save = r->tmp;
	
	for (i = 0; i < nmemb; i++) {
		if ((j = rand_uint32(r) % (nmemb - 1)) != i) {
			src = start + (size * i);
			dst = start + (size * j);
			memcpy(save, dst, size);
			memcpy(dst, src, size);
			memcpy(src, save, size);
		}
	}
	return (0);
}
示例#2
0
//----[  compileDropSequence  ]------------------------------------------------
void GlobalTreasure::compileDropSequence(
    TreasureDropSequenceElement* elements,
    size_t number_of_elements) {
  unsigned int common_threshold
    = (UINT_MAX-2) * (double)(percent_equipment_.getValue() / 100.0);
  unsigned int uncommon_threshold
    = common_threshold * (double)(percent_uncommon_.getValue() / 100.0);
  unsigned int rare_threshold
    = uncommon_threshold * (double)(percent_uncommons_rare_.getValue() / 100.0);
  rare_threshold = uncommon_threshold - rare_threshold;
  uncommon_threshold = common_threshold - uncommon_threshold;
  common_threshold = (UINT_MAX-2) - common_threshold;
  uncommon_threshold += common_threshold;
  rare_threshold += uncommon_threshold;
  assert(common_threshold < uncommon_threshold);
  assert(uncommon_threshold < rare_threshold);

  unsigned int gold_threshold
    = (UINT_MAX-2) * (double)(1.0 - percent_gold_.getValue() / 100.0);
  unsigned int consumable_threshold
    = (UINT_MAX-2) * (double)(1.0 - percent_consumables_.getValue() / 100.0);

  for (int i = 0; i < number_of_elements; ++i) {
    // use exclusive comparisons (>) instead of inclusive (>=) so that
    // setting something to a drop % of 0 makes it never drop
    unsigned int gold = rand_uint32();
    unsigned int consumable = rand_uint32();
    unsigned int equipment = rand_uint32();
    if (equipment > rare_threshold) {
      elements[i].equipment = TreasureDropSequenceElement::RARE;
    } else if (equipment > uncommon_threshold) {
      elements[i].equipment = TreasureDropSequenceElement::UNCOMMON;
    } else if (equipment > common_threshold) {
      elements[i].equipment = TreasureDropSequenceElement::COMMON;
    } else {
      elements[i].equipment = TreasureDropSequenceElement::NONE;
    }
    elements[i].gold = gold > gold_threshold;
    elements[i].consumable = consumable > consumable_threshold;
  }
}
示例#3
0
int ConnClient::prepare_req_conn(const sockaddr* addr, uv_udp_t* handle) {
	_addr = *addr;
	_udp = handle;

	_status = CONV_REQ_CONN;
	_next_req_conn_tick = 0;

	_req_conn_times = 10;
	_req_conn.conv = CONV_REQ_CONN;
	_req_conn.n = rand_uint32();

	return 0;
}
示例#4
0
unsigned int random_u32(unsigned int seed)
{
	rand_t *r;
	int rv;
	unsigned int rand;
	r = rand_open();
	if (r == NULL) return -1;
	rv = rand_set(r,&seed,4);
	if (r == NULL) return -1;
	
	rand = rand_uint32(r);
	r = rand_close(r);
	return rand;
}
示例#5
0
static struct hostent *lumberjack_choose_address(const char *host) {
  strlist_t *hostlist;
  split(&hostlist, host, ",");
  insist(hostlist->nitems > 0, "host string must not be empty");

  struct backoff sleeper;
  backoff_init(&sleeper, &MIN_SLEEP, &MAX_SLEEP);

  struct hostent *hostinfo = NULL;
  while (hostinfo == NULL) {
    int item = rand_uint32() % hostlist->nitems;
    char *chosen = hostlist->items[item];
    flog_if_slow(stdout, 0.200, {
      hostinfo = gethostbyname(chosen);
    }, "gethostbyname('%s')", chosen);
示例#6
0
//----[  AvatarMeleeDamage  ]--------------------------------------------------
int AvatarMeleeDamage(Avatar::AvatarLevel avatar_level,
                      int min_damage,
                      int max_damage,
                      int strength,
                      Avatar::AvatarClass avatar_class) {
  float expected_str = 15.0 + avatar_level / 3.5;
  float base_multiplier = 0.4 / (expected_str - 10);
  float multiplier = 0.25 + ((BoostedAvatarStat(strength)-10) * base_multiplier);
  // I removed this 9/30/2009 because players were complaining that strength
  // didn't do anything useful.
  //if (multiplier > 1.22) multiplier = 1.22;
  if (Avatar::AvatarClassIsMage(avatar_class)) multiplier /= 2.0;
  int damage_range = (max_damage - min_damage); // ensure it's at least 1
  damage_range = damage_range < 1 ? 1 : damage_range;
  return Time::Milliseconds(multiplier *
                            (min_damage + (rand_uint32()%damage_range)));

}
示例#7
0
struct personality *
personality_random(void)
{
	extern rand_t *honeyd_rand;
	struct personality *pers;
	int i;

	if (!npersons)
		return (NULL);

	i = rand_uint32(honeyd_rand) % npersons;
	pers = SPLAY_MIN(perstree, &personalities);
	while (i--) {
		pers = SPLAY_NEXT(perstree, &personalities, pers);
	}

	return (pers);
}
示例#8
0
void tlb_commands_till_exc_init(tst_t *tst, shared_mem_t *shared_ptr) {
    
    for(int i=1; i<32; i++) shared_ptr->initial.reg[i-1] = rand_uint32();
    
    shared_ptr->initial.pc = 0xA0001000;
    
    for(int i=0; i<64; i++) shared_ptr->initial.tlb[i].vpn = rand() & 0xFFFFF;
    
    shared_ptr->initial.index_p             = rand() & 0x1;
    shared_ptr->initial.index_index         = rand() & 0x3F;

    shared_ptr->initial.random              = rand() & 0x3F;

    shared_ptr->initial.entrylo_pfn         = rand() & 0xFFFFF;
    shared_ptr->initial.entrylo_n           = rand() & 0x1;
    shared_ptr->initial.entrylo_d           = rand() & 0x1;
    shared_ptr->initial.entrylo_v           = rand() & 0x1;
    shared_ptr->initial.entrylo_g           = rand() & 0x1;
    
    shared_ptr->initial.context_ptebase     = rand() & 0x7FF;
    shared_ptr->initial.context_badvpn      = rand() & 0x7FFFF;
    
    shared_ptr->initial.bad_vaddr           = rand_uint32();
    
    shared_ptr->initial.entryhi_vpn         = rand() & 0xFFFFF;
    shared_ptr->initial.entryhi_asid        = rand() & 0x3F;
    
    shared_ptr->initial.sr_cp_usable        = rand() & 0xF;
    shared_ptr->initial.sr_rev_endian       = rand() & 0x1;
    shared_ptr->initial.sr_bootstrap_vec    = rand() & 0x1;
    shared_ptr->initial.sr_tlb_shutdown     = rand() & 0x1;
    shared_ptr->initial.sr_parity_err       = rand() & 0x1;
    shared_ptr->initial.sr_cache_miss       = rand() & 0x1;
    shared_ptr->initial.sr_parity_zero      = rand() & 0x1;
    shared_ptr->initial.sr_switch_cache     = rand() & 0x1;
    shared_ptr->initial.sr_isolate_cache    = rand() & 0x1;
    shared_ptr->initial.sr_irq_mask         = rand() & 0xFF;
    shared_ptr->initial.sr_ku_ie            = rand() & 0x3F;
    
    shared_ptr->initial.cause_branch_delay  = rand() & 0x1;
    shared_ptr->initial.cause_cp_error      = rand() & 0x3;
    shared_ptr->initial.cause_irq_pending   = 0;
    shared_ptr->initial.cause_exc_code      = rand() & 0x1F;
    
    shared_ptr->initial.epc                 = rand_uint32();
    
    //
    shared_ptr->irq2_at_event = 0xFFFFFFFF;
    shared_ptr->irq3_at_event = 0xFFFFFFFF;
    
    //
    uint32 *ptr = &shared_ptr->mem.ints[(shared_ptr->initial.pc & 0x1FFFFFFF) / 4];
    
    for(int i=0; i<100; i++) {
        
        uint32 type = rand() % 5;
        
        if(type == 0) { //RFE
            (*ptr) = rand() & 0x01FFFFC0;
            (*ptr) |= (0b0100 << 28) | (0b00 << 26) | (0b1 << 25) | (0b010000 << 0);
        }
        else if(type == 1) { //TLBWR
            (*ptr) = rand() & 0x01FFFFC0;
            (*ptr) |= (0b0100 << 28) | (0b00 << 26) | (0b1 << 25) | (0b000110 << 0);
            
            ptr++;
            (*ptr) = rand() & 0x03FFFFC0;
            (*ptr) |= 0b001100; //SYSCALL
        }
        else if(type == 2) { //TLBWI
            (*ptr) = rand() & 0x01FFFFC0;
            (*ptr) |= (0b0100 << 28) | (0b00 << 26) | (0b1 << 25) | (0b000010 << 0);
            
            ptr++;
            (*ptr) = rand() & 0x03FFFFC0;
            (*ptr) |= 0b001100; //SYSCALL
        }
        else if(type == 3) { //TLBR
            (*ptr) = rand() & 0x01FFFFC0;
            (*ptr) |= (0b0100 << 28) | (0b00 << 26) | (0b1 << 25) | (0b000001 << 0);
        }
        else if(type == 4) { //TLBP
            (*ptr) = rand() & 0x01FFFFC0;
            (*ptr) |= (0b0100 << 28) | (0b00 << 26) | (0b1 << 25) | (0b001000 << 0);
        }
        
        ptr++;
    }
    
    for(int i=0; i<5; i++) {
        (*ptr) = rand() & 0x03FFFFC0;
        (*ptr) |= 0b001100; //SYSCALL
        ptr++;
    }
}
示例#9
0
//----[  MonsterGold  ]--------------------------------------------------------
unsigned int MonsterGold(Avatar::AvatarLevel intended_level) {
  if (intended_level > Avatar::HIGHEST_AVATAR_LEVEL) {
    intended_level = Avatar::HIGHEST_AVATAR_LEVEL;
  }
  return 2 * intended_level + 10 + rand_uint32()%(1+intended_level);
}
示例#10
0
void interrupt_till_exc_init(tst_t *tst, shared_mem_t *shared_ptr) {
    
    for(int i=1; i<32; i++) shared_ptr->initial.reg[i-1] = rand_uint32();
    
    shared_ptr->initial.pc = 0xA0001000;
    
    //tlb left zero
    
    shared_ptr->initial.index_p             = rand() & 0x1;
    shared_ptr->initial.index_index         = rand() & 0x3F;

    shared_ptr->initial.random              = rand() & 0x3F;

    shared_ptr->initial.entrylo_pfn         = rand() & 0xFFFFF;
    shared_ptr->initial.entrylo_n           = rand() & 0x1;
    shared_ptr->initial.entrylo_d           = rand() & 0x1;
    shared_ptr->initial.entrylo_v           = rand() & 0x1;
    shared_ptr->initial.entrylo_g           = rand() & 0x1;
    
    shared_ptr->initial.context_ptebase     = rand() & 0x7FF;
    shared_ptr->initial.context_badvpn      = rand() & 0x7FFFF;
    
    shared_ptr->initial.bad_vaddr           = rand_uint32();
    
    shared_ptr->initial.entryhi_vpn         = rand() & 0xFFFFF;
    shared_ptr->initial.entryhi_asid        = rand() & 0x3F;
    
    shared_ptr->initial.sr_cp_usable        = rand() & 0xF;
    shared_ptr->initial.sr_rev_endian       = rand() & 0x1;
    shared_ptr->initial.sr_bootstrap_vec    = rand() & 0x1;
    shared_ptr->initial.sr_tlb_shutdown     = rand() & 0x1;
    shared_ptr->initial.sr_parity_err       = rand() & 0x1;
    shared_ptr->initial.sr_cache_miss       = rand() & 0x1;
    shared_ptr->initial.sr_parity_zero      = rand() & 0x1;
    shared_ptr->initial.sr_switch_cache     = rand() & 0x1;
    shared_ptr->initial.sr_isolate_cache    = rand() & 0x1;
    shared_ptr->initial.sr_irq_mask         = rand() & 0xFF;
    shared_ptr->initial.sr_ku_ie            = rand() & 0x3F;
    
    shared_ptr->initial.cause_branch_delay  = rand() & 0x1;
    shared_ptr->initial.cause_cp_error      = rand() & 0x3;
    shared_ptr->initial.cause_irq_pending   = 0;
    shared_ptr->initial.cause_exc_code      = rand() & 0x1F;
    
    shared_ptr->initial.epc                 = rand_uint32();
    
    //
    uint32 *ptr = &shared_ptr->mem.ints[(shared_ptr->initial.pc & 0x1FFFFFFF) / 4];
    
    (*ptr) = 0;
    ptr++;
    
    (*ptr) = 0;
    ptr++;
    
    (*ptr) = 0;
    ptr++;
    
    (*ptr) = rand() & 0x03FFFFC0;
    (*ptr) |= 0b001100; //SYSCALL
    ptr++;
    
    //
    bool irq3 = (rand() % 2) == 0;
    shared_ptr->irq2_at_event = (irq3)? 0xFFFFFFFF : 1;
    shared_ptr->irq3_at_event = (irq3)? 1          : 0xFFFFFFFF;
}
示例#11
0
//----[  WinMain  ]------------------------------------------------------------
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE, LPSTR, int) {
  sqlite3* db;
  sqlite3_open(":memory:", &db);
  char* errmsg;

  // create the data structure
  char sql[2048];
  sqlite3_snprintf(2048,
                   sql,
                   "CREATE VIRTUAL TABLE entity_tree USING rtree(id, min_x, max_x, min_z, max_z)");
  if (SQLITE_OK != sqlite3_exec(db, sql, NULL, NULL, &errmsg)) {
    DEBUG_INFO("%s", errmsg);
    return 0;
  }
  sqlite3_snprintf(2048,
                   sql,
                   "CREATE TABLE entities (id INTEGER PRIMARY KEY, x REAL, z REAL, entity_ptr BLOB)");
  if (SQLITE_OK != sqlite3_exec(db, sql, NULL, NULL, &errmsg)) {
    DEBUG_INFO("%s", errmsg);
    return 0;
  }

  sqlite3_create_function(db,
                          "collision",
                          2,
                          SQLITE_ANY,
                          NULL, // user data ptr
                          collisionFunctionForSqlite,
                          NULL, NULL); // not an aggregating function

  static const size_t ENTITIES = 1024;
  static const size_t SIZE = 4096;


  enum Statement {
    STATEMENT_UPDATE_BOUNDARIES,
    STATEMENT_INSERT_ENTITY,
    STATEMENT_UPDATE_ENTITY,
    STATEMENT_QUERY_OVERLAP,
    STATEMENT_QUERY_COLLISION,
    NUMBER_OF_STATEMENTS,
  };

  struct Entity {
    int id;
    Number x, z;
    Number collision_rad_sq;
    Number visible_rad_sq;
    Number radius;
  };

  const char* statements_text[NUMBER_OF_STATEMENTS] = {
    "REPLACE INTO entity_tree VALUES (?,?,?,?,?)",
    "INSERT INTO entities VALUES (?,?,?,?)", // id, x, z, entity_ptr (blob)
    "UPDATE entities SET x=?, z=? WHERE id=?", // x, z, id
    "SELECT id FROM entity_tree WHERE id>? AND max_x>=? AND min_x<=? AND max_z>=? AND min_z<=?", // min/max x then min/max z
    // searcher's id, min x, max x, min z, max z
    "SELECT entities.id, entity_ptr FROM entities,entity_tree WHERE entities.id=entity_tree.id AND entity_tree.id>? AND collision(entities.x, entities.z) AND max_x>=? AND min_x<=? AND max_z>=? AND min_z<=?"
  };
  sqlite3_stmt* statements[NUMBER_OF_STATEMENTS];

  for (int i = 0; i <NUMBER_OF_STATEMENTS; ++i) {
    int rc;
    if (SQLITE_OK != (rc=sqlite3_prepare_v2(db,
                                        statements_text[i],
                                        strlen(statements_text[i]),
                                        &statements[i],
                                        NULL))) {

      DEBUG_INFO("%i - %s", i, sqlite3_errmsg(db));
    sqlite3_close(db);
      return false;
    }
  }

  Entity* entities = new Entity[ENTITIES];
  for (int i = 0; i < ENTITIES; ++i) {
    entities[i].id = i;
    entities[i].x = randf() * SIZE;
    entities[i].z = randf() * SIZE;
    float f = 0.5 + randf() * 1.0;
    entities[i].radius = f;
    entities[i].collision_rad_sq = f*f;
    f = 1.5f*randf() + f;
    entities[i].visible_rad_sq = f*f;

    sqlite3_bind_double(statements[STATEMENT_INSERT_ENTITY], 1, i);
    sqlite3_bind_double(statements[STATEMENT_INSERT_ENTITY], 2, entities[i].x.toFloat());
    sqlite3_bind_double(statements[STATEMENT_INSERT_ENTITY], 3, entities[i].z.toFloat());
    sqlite3_bind_blob(statements[STATEMENT_INSERT_ENTITY], 4, &entities[i], 4, SQLITE_TRANSIENT);
    sqlite3_step(statements[STATEMENT_INSERT_ENTITY]);
    sqlite3_reset(statements[STATEMENT_INSERT_ENTITY]);

    sqlite3_bind_int(statements[STATEMENT_UPDATE_BOUNDARIES], 1, entities[i].id);
    sqlite3_bind_double(statements[STATEMENT_UPDATE_BOUNDARIES], 2, (entities[i].x - entities[i].radius).toFloat());
    sqlite3_bind_double(statements[STATEMENT_UPDATE_BOUNDARIES], 3, (entities[i].x + entities[i].radius).toFloat());
    sqlite3_bind_double(statements[STATEMENT_UPDATE_BOUNDARIES], 4, (entities[i].z - entities[i].radius).toFloat());
    sqlite3_bind_double(statements[STATEMENT_UPDATE_BOUNDARIES], 5, (entities[i].z + entities[i].radius).toFloat());
    sqlite3_step(statements[STATEMENT_UPDATE_BOUNDARIES]);
    sqlite3_reset(statements[STATEMENT_UPDATE_BOUNDARIES]);
  }

  dcx::dcxWin32Clock clock;
  unsigned int counter = 0;
  double starter = clock.getAccurateSystemTime();
  double ender = starter + 5.0;
  double time=ender;
  unsigned int visible_tally = 0;
      collider_comparisons = 0;
#define TIMETRIAL
#ifdef TIMETRIAL
  while ((time = clock.getAccurateSystemTime()) < ender) {
#else
  while (counter < 1) {
#endif
    for (int i = 0; i < ENTITIES; ++i) {
      collider_x = entities[i].x = randf()*SIZE;
      collider_z = entities[i].z = randf()*SIZE;
      collider_rsq = entities[i].collision_rad_sq;
    sqlite3_bind_int(statements[STATEMENT_UPDATE_ENTITY], 3, entities[i].id);
    sqlite3_bind_double(statements[STATEMENT_UPDATE_ENTITY], 1, collider_x.toFloat());
    sqlite3_bind_double(statements[STATEMENT_UPDATE_ENTITY], 2, collider_z.toFloat());
    sqlite3_step(statements[STATEMENT_UPDATE_ENTITY]);
    sqlite3_reset(statements[STATEMENT_UPDATE_ENTITY]);

      float minx = (entities[i].x - entities[i].radius).toFloat();
      float maxx = (entities[i].x + entities[i].radius).toFloat();
      float minz = (entities[i].x - entities[i].radius).toFloat();
      float maxz = (entities[i].x + entities[i].radius).toFloat();
    sqlite3_bind_int(statements[STATEMENT_UPDATE_BOUNDARIES], 1, entities[i].id);
    sqlite3_bind_double(statements[STATEMENT_UPDATE_BOUNDARIES], 2, minx);
    sqlite3_bind_double(statements[STATEMENT_UPDATE_BOUNDARIES], 3, maxx);
    sqlite3_bind_double(statements[STATEMENT_UPDATE_BOUNDARIES], 4, minz);
    sqlite3_bind_double(statements[STATEMENT_UPDATE_BOUNDARIES], 5, maxz);
    sqlite3_step(statements[STATEMENT_UPDATE_BOUNDARIES]);
    sqlite3_reset(statements[STATEMENT_UPDATE_BOUNDARIES]);
#if 0
      sqlite3_bind_int(statements[STATEMENT_QUERY_OVERLAP], 1, entities[i].id);
      sqlite3_bind_double(statements[STATEMENT_QUERY_OVERLAP], 2, (collider_x - entities[i].radius).toFloat());
      sqlite3_bind_double(statements[STATEMENT_QUERY_OVERLAP], 3, (collider_x + entities[i].radius).toFloat());
      sqlite3_bind_double(statements[STATEMENT_QUERY_OVERLAP], 4, (collider_z - entities[i].radius).toFloat());
      sqlite3_bind_double(statements[STATEMENT_QUERY_OVERLAP], 5, (collider_z + entities[i].radius).toFloat());
      while (SQLITE_ROW == sqlite3_step(statements[STATEMENT_QUERY_OVERLAP])) {
        Entity* entity = (Entity*)sqlite3_column_blob(statements[STATEMENT_QUERY_OVERLAP], 1);
        ++visible_tally;
#ifndef TIMETRIAL
        DEBUG_INFO("collision = %i with %i @ %.02f, %.02f",
          entities[i].id, sqlite3_column_int(statements[STATEMENT_QUERY_OVERLAP], 0),
          entity->x.toFloat(),
          entity->z.toFloat());
#endif
      }
      sqlite3_reset(statements[STATEMENT_QUERY_OVERLAP]);
#endif

      sqlite3_bind_int(statements[STATEMENT_QUERY_COLLISION], 1, entities[i].id);
      sqlite3_bind_double(statements[STATEMENT_QUERY_COLLISION], 2, (collider_x - entities[i].radius).toFloat());
      sqlite3_bind_double(statements[STATEMENT_QUERY_COLLISION], 3, (collider_x + entities[i].radius).toFloat());
      sqlite3_bind_double(statements[STATEMENT_QUERY_COLLISION], 4, (collider_z - entities[i].radius).toFloat());
      sqlite3_bind_double(statements[STATEMENT_QUERY_COLLISION], 5, (collider_z + entities[i].radius).toFloat());
      while (SQLITE_ROW == sqlite3_step(statements[STATEMENT_QUERY_COLLISION])) {
        Entity* entity = (Entity*)sqlite3_column_blob(statements[STATEMENT_QUERY_COLLISION], 1);
        ++visible_tally;
#ifndef TIMETRIAL
        DEBUG_INFO("collision = %i with %i @ %.02f, %.02f",
          entities[i].id, sqlite3_column_int(statements[STATEMENT_QUERY_COLLISION], 0),
          entity->x.toFloat(),
          entity->z.toFloat());
#endif
      }
      sqlite3_reset(statements[STATEMENT_QUERY_COLLISION]);

#ifndef TIMETRIAL
      DEBUG_INFO("comparisons = %i", collider_comparisons);
#endif
    }

    ++counter;
  }

  for (int i = 0; i <NUMBER_OF_STATEMENTS; ++i) {
    sqlite3_finalize(statements[i]);
  }
  sqlite3_close(db);
  delete[] entities;
  DEBUG_INFO("%f queries/second; %f visible/entity (comparisons=%i)", counter / (time-starter), visible_tally/double(counter), collider_comparisons);

#if 0
  char sql[2048];

  // create the data structure
  sqlite3_snprintf(2048,
                   sql,
                   "CREATE TABLE IF NOT EXISTS objects ("\
                   "id INTEGER PRIMARY KEY,"\
                   "x INTEGER,"\
                   "z INTEGER"\
                   ")");
  char* errmsg;
  if (SQLITE_OK != sqlite3_exec(db, sql, NULL, NULL, &errmsg)) {
    DEBUG_INFO("%s", errmsg);
    return 0;
  }
  sqlite3_snprintf(2048,
                   sql,
                   "CREATE INDEX IF NOT EXISTS "\
                   "index_x "\
                   "ON objects (x)");
  if (SQLITE_OK != sqlite3_exec(db, sql, NULL, NULL, &errmsg)) {
    DEBUG_INFO("%s", errmsg);
    sqlite3_close(db);
    return false;
  }
  sqlite3_snprintf(2048,
                   sql,
                   "CREATE INDEX IF NOT EXISTS "\
                   "index_z "\
                   "ON objects (z)");
  if (SQLITE_OK != sqlite3_exec(db, sql, NULL, NULL, &errmsg)) {
    DEBUG_INFO("%s", errmsg);
    sqlite3_close(db);
    return false;
  }
  sqlite3_snprintf(2048,
                   sql,
                   "CREATE TABLE IF NOT EXISTS has_seen ("\
                   "a INTEGER,"\
                   "b INTEGER"\
                   ")");
  if (SQLITE_OK != sqlite3_exec(db, sql, NULL, NULL, &errmsg)) {
    DEBUG_INFO("%s", errmsg);
    sqlite3_close(db);
    return false;
  }
  sqlite3_snprintf(2048,
                   sql,
                   "CREATE INDEX IF NOT EXISTS "\
                   "index_a "\
                   "ON has_seen (a)");
  if (SQLITE_OK != sqlite3_exec(db, sql, NULL, NULL, &errmsg)) {
    DEBUG_INFO("%s", errmsg);
    sqlite3_close(db);
    return false;
  }
  sqlite3_snprintf(2048,
                   sql,
                   "CREATE INDEX IF NOT EXISTS "\
                   "index_b "\
                   "ON has_seen (b)");
  if (SQLITE_OK != sqlite3_exec(db, sql, NULL, NULL, &errmsg)) {
    DEBUG_INFO("%s", errmsg);
    sqlite3_close(db);
    return false;
  }
  sqlite3_snprintf(2048,
                   sql,
                   "CREATE TABLE IF NOT EXISTS results ("\
                   "id INTEGER PRIMARY KEY,"\
                   "x INTEGER,"\
                   "z INTEGER"\
                   ")");

  if (SQLITE_OK != sqlite3_exec(db, sql, NULL, NULL, &errmsg)) {
    DEBUG_INFO("%s", errmsg);
    return 0;
  }
  sqlite3_exec(db, "PRAGMA case_sensitive_like=ON;", NULL, NULL, NULL);
  sqlite3_exec(db, "PRAGMA synchronous=OFF;", NULL, NULL, NULL);
  sqlite3_exec(db, "PRAGMA count_changes=OFF;", NULL, NULL, NULL);

  static const int COUNT = 256;
  static const int SIZE = 64;
  // insert a bunch of random objects
  for (int i = 0; i < COUNT; ++i) {
    sqlite3_snprintf(2048,
                     sql,
                     "INSERT INTO objects (id, x, z) VALUES "\
                     "(%i, %i, %i)",
                     i,
                     rand_uint32()%SIZE,
                     rand_uint32()%SIZE);
    if (SQLITE_OK != sqlite3_exec(db, sql, NULL, NULL, &errmsg)) {
      DEBUG_INFO("%s", errmsg);
    sqlite3_close(db);
      return false;
    }
  }

  enum Statement {
    STATEMENT_CURRENT_VISIBILITY_QUERY,
    STATEMENT_NEW_VISIBILITY_QUERY,
    STATEMENT_INSERT_HAS_SEEN,
    NUMBER_OF_STATEMENTS,
  };

  const char* statements_text[NUMBER_OF_STATEMENTS] = {
    "SELECT id, x, z FROM objects WHERE (x BETWEEN ? AND ?) AND (z BETWEEN ? AND ?)",
    "SELECT id FROM objects WHERE (x BETWEEN ? AND ?) AND (z BETWEEN ? AND ?) EXCEPT SELECT (a) FROM has_seen WHERE (b=?)",
    "INSERT INTO has_seen (a,b) VALUES (?,?)"
  };
  sqlite3_stmt* statements[NUMBER_OF_STATEMENTS];

  for (int i = 0; i <NUMBER_OF_STATEMENTS; ++i) {
    int rc;
    if (SQLITE_OK != (rc=sqlite3_prepare_v2(db,
                                        statements_text[i],
                                        strlen(statements_text[i]),
                                        &statements[i],
                                        NULL))) {

      DEBUG_INFO("%i-%s", i, sqlite3_errmsg(db));
    sqlite3_close(db);
      return false;
    }
  }

  dcx::dcxWin32Clock clock;
  unsigned int counter = 0;
  double starter = clock.getAccurateSystemTime();
  double ender = starter + 1.0;
  double time=ender;
  unsigned int visible_tally = 0;
#define TIMETRIAL
#ifdef TIMETRIAL
  while ((time = clock.getAccurateSystemTime()) < ender) {
#else
  while (counter < 64) {
#endif
    double x = counter;
    double z = counter;
    sqlite3_bind_int(statements[STATEMENT_NEW_VISIBILITY_QUERY], 1, x -8);
    sqlite3_bind_int(statements[STATEMENT_NEW_VISIBILITY_QUERY], 2, x +8);
    sqlite3_bind_int(statements[STATEMENT_NEW_VISIBILITY_QUERY], 3, z - 8);
    sqlite3_bind_int(statements[STATEMENT_NEW_VISIBILITY_QUERY], 4, z + 8);
    sqlite3_bind_int(statements[STATEMENT_NEW_VISIBILITY_QUERY], 5, COUNT);

    //sqlite3_bind_int(statements[STATEMENT_CURRENT_VISIBILITY_QUERY], 1, x -8);
    //sqlite3_bind_int(statements[STATEMENT_CURRENT_VISIBILITY_QUERY], 2, x +8);
    //sqlite3_bind_int(statements[STATEMENT_CURRENT_VISIBILITY_QUERY], 3, z - 8);
    //sqlite3_bind_int(statements[STATEMENT_CURRENT_VISIBILITY_QUERY], 4, z + 8);
#ifndef TIMETRIAL
    char buffer[512];
    sprintf_s(buffer, 512, "\n====   %f, %f   ============\n", x, z);
    OutputDebugString(buffer);
#endif
    while (sqlite3_step(statements[STATEMENT_NEW_VISIBILITY_QUERY]) == SQLITE_ROW) {
#ifndef TIMETRIAL
      char buffer[512];
      sprintf_s(buffer, 512, " %lu %8f, %8f\n", sqlite3_column_int(statements[STATEMENT_NEW_VISIBILITY_QUERY], 0), sqlite3_column_double(statements[STATEMENT_NEW_VISIBILITY_QUERY], 1), sqlite3_column_double(statements[STATEMENT_NEW_VISIBILITY_QUERY], 2));
      OutputDebugString(buffer);
#endif

      //sqlite3_bind_int(statements[STATEMENT_INSERT_HAS_SEEN], 1, sqlite3_column_int(statements[STATEMENT_NEW_VISIBILITY_QUERY],0));
      //sqlite3_bind_int(statements[STATEMENT_INSERT_HAS_SEEN], 2, COUNT);
      //sqlite3_step(statements[STATEMENT_INSERT_HAS_SEEN]);
      //sqlite3_reset(statements[STATEMENT_INSERT_HAS_SEEN]);
      visible_tally++;
    }
    sqlite3_reset(statements[STATEMENT_NEW_VISIBILITY_QUERY]);
    sqlite3_reset(statements[STATEMENT_CURRENT_VISIBILITY_QUERY]);
    ++counter;
  }

  for (int i = 0; i <NUMBER_OF_STATEMENTS; ++i) {
    sqlite3_finalize(statements[i]);
  }
  sqlite3_close(db);
  DEBUG_INFO("%f queries/second; %f visible/entity (tally=%i)", counter / (time-starter), visible_tally/double(counter), visible_tally);
#endif

//  sqlite3* db;
//  sqlite3_open(":memory:", &db);
//
//  char sql[2048];
//
//  // create the data structure
//  sqlite3_snprintf(2048,
//                   sql,
//                   "CREATE TABLE IF NOT EXISTS objects ("\
//                   "id INTEGER PRIMARY KEY,"\
//                   "x REAL,"\
//                   "z REAL"\
//                   ")");
//  char* errmsg;
//  if (SQLITE_OK != sqlite3_exec(db, sql, NULL, NULL, &errmsg)) {
//    DEBUG_INFO("%s", errmsg);
//    return 0;
//  }
//  sqlite3_snprintf(2048,
//                   sql,
//                   "CREATE INDEX IF NOT EXISTS "\
//                   "index_x "\
//                   "ON objects (x)");
//  if (SQLITE_OK != sqlite3_exec(db, sql, NULL, NULL, &errmsg)) {
//    DEBUG_INFO("%s", errmsg);
//    sqlite3_close(db);
//    return false;
//  }
//  sqlite3_snprintf(2048,
//                   sql,
//                   "CREATE INDEX IF NOT EXISTS "\
//                   "index_z "\
//                   "ON objects (z)");
//  if (SQLITE_OK != sqlite3_exec(db, sql, NULL, NULL, &errmsg)) {
//    DEBUG_INFO("%s", errmsg);
//    sqlite3_close(db);
//    return false;
//  }
//  sqlite3_exec(db, "PRAGMA case_sensitive_like=ON;", NULL, NULL, NULL);
//  sqlite3_exec(db, "PRAGMA synchronous=OFF;", NULL, NULL, NULL);
//  sqlite3_exec(db, "PRAGMA count_changes=OFF;", NULL, NULL, NULL);
//
//  static const int COUNT = 16000;
//  static const float SIZE = 2048;
//  // insert a bunch of random objects
//  for (int i = 0; i < COUNT; ++i) {
//    sqlite3_snprintf(2048,
//                     sql,
//                     "INSERT INTO objects (id, x, z) VALUES "\
//                     "(%i, %f, %f)",
//                     i,
//                     randf()*SIZE,
//                     randf()*SIZE);
//    if (SQLITE_OK != sqlite3_exec(db, sql, NULL, NULL, &errmsg)) {
//      DEBUG_INFO("%s", errmsg);
//    sqlite3_close(db);
//      return false;
//    }
//  }
//
//  // create a query
//  sqlite3_snprintf(2048,
//                   sql,
//                   "SELECT id, x, z FROM objects "\
//                   "WHERE x>=? AND x<=? AND z>=? AND z<=?");
//  sqlite3_stmt* stmt = NULL;
//  if (SQLITE_OK != sqlite3_prepare_v2(db,
//                                      sql,
//                                      sizeof(sql),
//                                      &stmt,
//                                      NULL)) {
//    return false;
//  }
//
//  dcx::dcxWin32Clock clock;
//  unsigned int counter = 0;
//  double starter = clock.getAccurateSystemTime();
//  double ender = starter + 1;
//  double time;
//  unsigned int visible_tally = 0;
//  while ((time = clock.getAccurateSystemTime()) < ender) {
//  //while (counter < 64) {
//    double x = 32.0f;
//    double z = randf()*SIZE;
//    sqlite3_bind_double(stmt, 1, x - 8.0);
//    sqlite3_bind_double(stmt, 2, x + 8.0);
//    sqlite3_bind_double(stmt, 3, z - 8.0);
//    sqlite3_bind_double(stmt, 4, z + 8.0);
//    //char buffer[512];
//    //sprintf_s(buffer, 512, "\n====   %f, %f   ============\n", x, z);
//    //OutputDebugString(buffer);
//    while (sqlite3_step(stmt) == SQLITE_ROW) {
//      //char buffer[512];
//      //sprintf_s(buffer, 512, " %lu %8f, %8f\n", sqlite3_column_int(stmt, 0), sqlite3_column_double(stmt, 1), sqlite3_column_double(stmt, 2));
//      //OutputDebugString(buffer);
//      visible_tally++;
//    }
//    sqlite3_reset(stmt);
//    ++counter;
//  }
//  sqlite3_finalize(stmt);
//  sqlite3_close(db);
//  DEBUG_INFO("%f queries/second; %f visible/entity", counter / (time-starter), visible_tally/double(counter));
}
示例#12
0
//----[  randfExclusive  ]-----------------------------------------------------
float randfExclusive() {
  return float(double(rand_uint32()) / double(0x100000000));
}
示例#13
0
//----[  randfSymmetric  ]-----------------------------------------------------
float randfSymmetric() {
  return float((double(rand_uint32()) / double(0x7FFFFFFF)) - 1.0);
}
示例#14
0
//----[  randf64  ]------------------------------------------------------------
double randf64() {
  return double(rand_uint32()) / double(0xFFFFFFFF);
}
示例#15
0
//----[  randf32  ]------------------------------------------------------------
float randf32() {
  return float(double(rand_uint32()) / double(0xFFFFFFFF));
}