void *task(void *arg)
{
struct buffer *bp;
dev_nr_t dev_nr;
block_nr_t block_nr;
repeat:
process_mode_kernel();
dev_nr = random_get(NR_DEV);
block_nr = random_get(NR_DISK_BLOCKS);
printf("cache_bread(%i, %i)\n", dev_nr, block_nr);
bp = cache_bread(dev_nr, block_nr);
buffer_set_dirty(bp);
printf("cache_brelse(bp)\n");
cache_brelse(bp);
printf("free buffers:\t\t%09u\n", cache_number_free_blocks());
printf("cache hits:\t\t%09lu\n", cache_hits());
printf("cache misses:\t\t%09lu\n", cache_misses());
process_mode_user();
goto repeat;
return NULL;
}
uint8_t slave_null_read_data(uint8_t slave_addr, uint8_t* buf, uint8_t max_len)
{
/* limit number of registers to the max. available */
if(max_len > sizeof(modbus_null_input_register_list))
{
max_len = sizeof(modbus_null_input_register_list);
}
#if MODBUS_NULL_SLAVE_SIMULATION == 0
/* Detecta equipamentos de medição e faz a leitura dos dados */
NULL_IRList.Reg.Pressure_Valve = sensors_read(PRESSURE_VALVE);
NULL_IRList.Reg.Oil_Level = sensors_read(SENSOR_LEVEL);
FATFS *fs; /* Pointer to file system object */
uint32_t p1;
if (f_getfree(".", (DWORD*)&p1, &fs) == FR_OK)
{
NULL_IRList.Reg.SD_bytes_available = (uint32_t)(p1 * fs->csize * 512);
}
NULL_IRList.Reg.Local_time = (uint32_t)simon_clock_get();
#else
uint8_t nregs = 0;
/* return random data */
for(nregs = NULL_REGLIST_OFFSET_NREGS; nregs < (NULL_REGLIST_INPUT_NREGS+NULL_REGLIST_OFFSET_NREGS);nregs++)
{
NULL_IRList.Regs16[nregs] = random_get();
}
#endif
/* get and set timestamp of reading and device id */
SetModbusHeader(slave_addr, NULL_IRList.Regs8);
memcpy(buf,NULL_IRList.Regs8,max_len);
return (max_len);
}
static void
put_welcoming_message (void)
{
uint64_t r = random_get () % chaos_quotes_count;
videoram_printf ("\n``%s''\n -- %s\n\n",
chaos_quotes[r][0], chaos_quotes[r][1]);
videoram_puts ("Press ctrl+shift+esc+H to see possible commands.\n\n",
COLOR_NORMAL);
}
unsigned long int
x86_nop_rwreg (void)
{
unsigned long int reg;
do {
reg = random_get (0, 7);
} while (reg == 4); /* 4 = $esp */
return (reg);
}
inline int
random_in_range_percent(int base, float percent)
{
float percentage;
int variance;
percentage = percent / 100.0;
variance = (int) (percentage * base);
variance = random_get(variance * 2) - variance;
return base + variance;
}
/**
* @brief Initialize global hash move data.
*/
void hash_move_init(void)
{
int i, j;
Random r;
random_seed(&r, 0x5DEECE66Dull);
for (i = 0; i < 64; ++i)
for (j = 0; j < 60; ++j) {
do {
hash_move[i][j] = random_get(&r);
} while (bit_count(hash_move[i][j]) < 8);
}
}
/**
* @brief Initialize global hash code data.
*/
void hash_code_init(void)
{
int i, j;
Random r;
random_seed(&r, 0x5DEECE66Dull);
for (i = 0; i < 16; ++i)
for (j = 0; j < 256; ++j) {
do {
hash_rank[i][j] = random_get(&r);
} while (bit_count(hash_rank[i][j]) < 8);
}
}
unsigned int
x86_nop (unsigned char *dest, unsigned int dest_len,
unsigned char *bad, int bad_len)
{
int walk;
int bcount; /* bad counter */
char * xs;
char * xferstr[] = {
"0011.0111", /* aaa */
"0011.1111", /* aas */
"1001.1000", /* cbw */
"1001.1001", /* cdq */
"1111.1000", /* clc */
"1111.1100", /* cld */
"1111.0101", /* cmc */
"0010.0111", /* daa */
"0010.1111", /* das */
"0100.1r", /* dec <reg> */
"0100.0r", /* inc <reg> */
"1001.1111", /* lahf */
"1001.0000", /* nop */
"1111.1001", /* stc */
"1111.1101", /* std */
"1001.0r", /* xchg al, <reg> */
NULL,
};
unsigned char tgt;
for (walk = 0 ; dest_len > 0 ; dest_len -= 1 , walk += 1) {
/* avoid endless loops on excessive badlisting */
for (bcount = 0 ; bcount < 16384 ; ++bcount) {
xs = xferstr[random_get (0, 15)];
tgt = x86_nop_xfer (xs);
dest[walk] = tgt;
if (badstr (&dest[walk], 1, bad, bad_len) == 0)
break;
}
/* should not happen */
if (bcount >= 16384) {
fprintf (stderr, "too much blacklisting, giving up...\n");
exit (EXIT_FAILURE);
}
}
return (walk);
}
static void diamond_square(int *map, int side_len) {
#define INDEX(x, y) ((y)*side_len+(x))
int x, y, len=side_len, half, r=5000, tmp;
map[0]=map[INDEX(len-1, 0)]=map[INDEX(0, len-1)]=map[INDEX(len-1, len-1)]=r/2;
for(len=side_len-1; len>=2; len/=2, r/=2) {
half=len/2;
for(y=0; y<side_len-1; y+=len)
for(x=0; x<side_len-1; x+=len) {
if(map[INDEX(x+half, y+half)])
continue;
map[INDEX(x+half, y+half)]=(map[INDEX(x, y)]+map[INDEX(x+len, y)]+map[INDEX(x, y+len)]+map[INDEX(x+len, y+len)])/4+random_get()%r;
if(r<5000)
map[INDEX(x+half, y+half)]-=r/2;
else
map[INDEX(x+half, y+half)]=0;
}
for(y=0; y<side_len-1; y+=half)
for(x=(y+half)%len; x<side_len-1; x+=len) {
if(map[INDEX(x, y)])
continue;
tmp=(map[INDEX((x-half+len)%side_len, y)]+map[INDEX((x+half)%side_len, y)]+map[INDEX(x, (y-half+len)%side_len)]+map[INDEX(x, (y+half)%side_len)])/4+random_get()%r;
if(r<5000)
tmp-=r/2;
else
tmp=0;
map[INDEX(x, y)]=tmp;
if(!x)
map[INDEX(side_len-1, y)]=tmp;
if(!y)
map[INDEX(x, side_len-1)]=tmp;
}
}
#undef INDEX
}
int main(int argc, char *argv[])
{
if(argc<2)
{
printf("Usage: %s [puzzle file] \n\n", argv[0]);
return 0;
}
if(argc==3 && strcmp(argv[2], "debug")==0)
debug=1;
/* seed random number generator */
random_seed();
/* read num tiles */
int ntiles = input_get_ntiles(argv[1]);
if(ntiles==0)
{
printf("input file error: %s\n", argv[1]);
return 0;
}
/* create data structures */
e2_t e2;
e2.board = malloc(ntiles*sizeof(int));
e2.tiles = malloc((ntiles+1)*sizeof(tile_t)); // ignore zero position
e2.ntiles = ntiles;
e2.side = sqrt(ntiles);
printf("ntiles: %d\n", e2.ntiles);
printf("side: %d\n", e2.side);
/* set data */
input_read_tiles(&e2, argv[1]);
board_set_tiles(&e2);
/* print data structures */
//output_tiles(&e2);
output_board_file(&e2, "/dev/stdout");
printf("------------------------------------------------------------\n");
printf("\n\n");
int merror, tmp_merror;
int src_x, src_y, dst_x, dst_y;
int max_lock = ntiles*ntiles;
int lock=0;
int nlocks=0;
int it=0;
int lmi_n=1;
int lmi_me=ntiles*4;
/* solved? */
while((merror = match_get_num_total_errors(&e2))!=0)
{
src_x = random_get(e2.side);
src_y = random_get(e2.side);
do { random_get_optimal_xy(&e2, src_x, src_y, &dst_x, &dst_y); }
//do { random_get_xy_by_groups(&e2, src_x, src_y, &dst_x, &dst_y); }
while(src_x==dst_x && src_y==dst_y);
board_swap_tiles(&e2, src_x, src_y, dst_x, dst_y);
rotation_auto(&e2, src_x, src_y);
rotation_auto(&e2, dst_x, dst_y);
tmp_merror = match_get_num_total_errors(&e2);
if(tmp_merror < merror)
{
nlocks++;
lock=0;
merror = tmp_merror;
printf("merror: %d, lmi_me: %d, lmi_n: %d, it: %d, nlocks: %d",
merror, lmi_me, lmi_n, it, nlocks);
if(debug)
printf("\n");
else
printf("\r");
if(debug)
printf("swap src:%d(%d,%d) - dst:%d(%d,%d)\n",
board_get(&e2, src_x, src_y), src_x, src_y,
board_get(&e2, dst_x, dst_y), dst_x, dst_y);
if(debug)
{
output_board_file(&e2, "/dev/stdout");
printf("------------------------------------------------------\n");
}
if(it%100==0)
{
output_board_file(&e2, "/dev/stdout");
printf("------------------------------------------------------\n");
}
}
else
{
// undo
board_swap_tiles(&e2, dst_x, dst_y, src_x, src_y);
rotation_auto(&e2, src_x, src_y);
rotation_auto(&e2, dst_x, dst_y);
lock++;
}
// local minimal
if(lock > max_lock)
{
if(merror < lmi_me)
{
if(lmi_n>1) lmi_n --;
}
else
{
if(lmi_n<1) lmi_n ++;
}
lmi_me = merror;
int i;
for(i=0; i<lmi_n; i++)
{
src_x = random_get(e2.side);
src_y = random_get(e2.side);
do { random_get_optimal_xy(&e2, src_x, src_y, &dst_x, &dst_y); }
//do { random_get_xy_by_groups(&e2, src_x, src_y, &dst_x, &dst_y); }
while(src_x==dst_x && src_y==dst_y);
board_swap_tiles(&e2, src_x, src_y, dst_x, dst_y);
rotation_auto(&e2, src_x, src_y);
rotation_auto(&e2, dst_x, dst_y);
}
}
it++;
}
printf("\n\n");
printf("------------------------------------------------------------\n");
printf("Solved: \n");
printf("------------------------------------------------------------\n");
output_board_file(&e2, "/dev/stdout");
/* free data sctructures */
free(e2.board);
free(e2.tiles);
return 0;
}
