void m68k_end_timeslice(void)
{
#if 0
m68ki_initial_cycles = GET_CYCLES();
SET_CYCLES(0);
#else
initialCycles = regs.remainingCycles;
regs.remainingCycles = 0;
#endif
}
int fmemcmp_main(int argc, char ** argv) {
char * buf, * buf2;
uint32_t buflen, failure = 0, i;
unsigned int x,y;
unsigned int speed[3];
if(argc < 2) {
// No input num, just use 1000
buflen = 1000000;
} else {
buflen = atoi(argv[1]);
if(buflen == 0) return EXIT_FAILURE;
}
if(!(buf = malloc(buflen))) {
printf("Couldn't allocate memory.\n");
return 0;
}
printf("Allocated %u bytes\n", buflen);
if(!(buf2 = malloc(buflen))) {
printf("Couldn't allocate memory.\n");
return 0;
}
printf("Allocated %u bytes\n", buflen);
printf("Filling %u bytes with junk\n", buflen);
for(i=0; i<buflen; i++) {
buf[i] = buf2[i] = 1;
}
// TEST OF MEMCMP VS. FMEMCMP
printf("***************** FMEMCMP *****************\n");
printf("Running system memcmp: ");
GET_CYCLES(x);
if(memcmp(buf, buf2, buflen) != 0) failure = 1;
GET_CYCLES(y);
printf("time=%u, ", y-x);
speed[0] = y-x;
if(!failure) {
printf("Match!\n");
} else {
printf("No Match!\n");
}
failure = 0;
printf("Running forloop memcmp: ");
GET_CYCLES(x);
for(i=0; i<buflen; i++) {
if(buf[i] != buf2[i]) failure = 1;
}
GET_CYCLES(y);
printf("time=%u, ", y-x);
speed[1] = y-x;
if(!failure) {
printf("Match!\n");
} else {
printf("No Match!\n");
}
failure = 0;
printf("Running fmemcmp: ");
GET_CYCLES(x);
if((fmemcmp(buf, buf2, buflen)) != 0) failure = 1;
GET_CYCLES(y);
printf("time=%u, ", y-x);
speed[2] = y-x;
if(!failure) {
printf("Match!\n");
} else {
printf("No Match! (%d)\n", failure);
}
failure = 0;
// Summarize
printf(":: fmemcmp is %g times faster than system memcmp.\n", ((float)speed[0])/speed[2]);
printf(":: fmemcmp is %g times faster than forloop memcmp.\n", ((float)speed[1])/speed[2]);
printf("***************** FMEMCMP *****************\n");
return EXIT_SUCCESS;
}
int m68k_execute(int num_cycles)
{
if (regs.stopped)
{
regs.remainingCycles = 0; // int32_t
regs.interruptCycles = 0; // uint32_t
return num_cycles;
}
#if 0
/* Set our pool of clock cycles available */
SET_CYCLES(num_cycles);
m68ki_initial_cycles = num_cycles;
/* ASG: update cycles */
USE_CYCLES(CPU_INT_CYCLES);
CPU_INT_CYCLES = 0;
/* Return point if we had an address error */
m68ki_set_address_error_trap(); /* auto-disable (see m68kcpu.h) */
#else
regs.remainingCycles = num_cycles;
/*int32_t*/ initialCycles = num_cycles;
regs.remainingCycles -= regs.interruptCycles;
regs.interruptCycles = 0;
#endif
/* Main loop. Keep going until we run out of clock cycles */
do
{
// This is so our debugging code can break in on a dime.
// Otherwise, this is just extra slow down :-P
if (regs.spcflags & SPCFLAG_DEBUGGER)
{
// Not sure this is correct... :-P
num_cycles = initialCycles - regs.remainingCycles;
regs.remainingCycles = 0; // int32_t
regs.interruptCycles = 0; // uint32_t
return num_cycles;
}
#if 0
/* Set tracing accodring to T1. (T0 is done inside instruction) */
m68ki_trace_t1(); /* auto-disable (see m68kcpu.h) */
/* Set the address space for reads */
m68ki_use_data_space(); /* auto-disable (see m68kcpu.h) */
/* Call external hook to peek at CPU */
m68ki_instr_hook(); /* auto-disable (see m68kcpu.h) */
/* Record previous program counter */
REG_PPC = REG_PC;
/* Read an instruction and call its handler */
REG_IR = m68ki_read_imm_16();
m68ki_instruction_jump_table[REG_IR]();
USE_CYCLES(CYC_INSTRUCTION[REG_IR]);
/* Trace m68k_exception, if necessary */
m68ki_exception_if_trace(); /* auto-disable (see m68kcpu.h) */
#else
//Testing Hover Strike...
#if 0
//Dasm(regs.pc, 1);
static int hitCount = 0;
static int inRoutine = 0;
static int instSeen;
//if (regs.pc == 0x80340A)
if (regs.pc == 0x803416)
{
hitCount++;
inRoutine = 1;
instSeen = 0;
printf("%i: $80340A start. A0=%08X, A1=%08X ", hitCount, regs.regs[8], regs.regs[9]);
}
else if (regs.pc == 0x803422)
{
inRoutine = 0;
printf("(%i instructions)\n", instSeen);
}
if (inRoutine)
instSeen++;
#endif
// AvP testing... (problem was: 32 bit addresses on 24 bit address cpu--FIXED)
#if 0
static int go = 0;
if (regs.pc == 0x94BA)
{
go = 1;
printf("\n");
}
if (regs.pc == 0x94C6)
go = 0;
// if (regs.regs[10] == 0xFFFFFFFF && go)
if (go)
{
// printf("A2=-1, PC=%08X\n", regs.pc);
// go = 0;
// Dasm(regs.pc, 130);
Dasm(regs.pc, 1);
DumpRegisters();
}
//94BA: 2468 0000 MOVEA.L (A0,$0000) == $0002328A, A2
//94BE: 200A MOVE.L A2, D0
//94C0: 6A02 BPL.B $94C4
//94C2: 2452 MOVEA.L (A2), A2 ; <--- HERE
//94C4: 4283 CLR.L D3
#endif
// pthread_mutex_lock(&executionLock);
if (checkForIRQToHandle)
{
checkForIRQToHandle = 0;
m68k_set_irq2(IRQLevelToHandle);
}
#ifdef M68K_HOOK_FUNCTION
M68KInstructionHook();
#endif
uint32_t opcode = get_iword(0);
//if ((opcode & 0xFFF8) == 0x31C0)
//{
// printf("MOVE.W D%i, EA\n", opcode & 0x07);
//}
int32_t cycles = (int32_t)(*cpuFunctionTable[opcode])(opcode);
regs.remainingCycles -= cycles;
// pthread_mutex_unlock(&executionLock);
//printf("Executed opcode $%04X (%i cycles)...\n", opcode, cycles);
#endif
}
while (regs.remainingCycles > 0);
#if 0
/* set previous PC to current PC for the next entry into the loop */
REG_PPC = REG_PC;
/* ASG: update cycles */
USE_CYCLES(CPU_INT_CYCLES);
CPU_INT_CYCLES = 0;
/* return how many clocks we used */
return m68ki_initial_cycles - GET_CYCLES();
#else
regs.remainingCycles -= regs.interruptCycles;
regs.interruptCycles = 0;
// Return # of clock cycles used
return initialCycles - regs.remainingCycles;
#endif
}
int bin2hex_main(int argc, char ** argv) {
FILE * rand_fh;
char lt[256][2];
unsigned int x,y;
char * newhex_dest;
union {
uint32_t u32;
uint8_t u8[4];
} random_num;
uint16_t i;
printf("***************** BIN2HEX *****************\n");
if(bin2hex_init(lt) == 0) {
// Fail.. Leave
fprintf(stderr, "Unable to init lookup table.\n");
return EXIT_FAILURE;
}
rand_fh = fopen("/dev/urandom", "r");
if(!rand_fh) {
fprintf(stderr, "Unable to open random buffer.\n");
return EXIT_FAILURE;
}
printf("Table created: \n");
for(i=0; i<256; i++) {
printf("%c%c", lt[i][0], lt[i][1]);
if(i%15 == 0) printf("\n");
else printf(" ");
}
// Initialize crazy binary array
uint8_t * crazy_hex = malloc(CRAZY_SIZE);
for(i=0; i<CRAZY_SIZE-3; i++) {
if((fread(&random_num.u32, 4, 1, rand_fh) == 0)) {
fprintf(stderr, "Could not read 4 bytes from file.\n");
return EXIT_FAILURE;
}
crazy_hex[i] = random_num.u8[0];
crazy_hex[i+1] = random_num.u8[1];
crazy_hex[i+2] = random_num.u8[2];
crazy_hex[i+3] = random_num.u8[3];
i += 4;
}
char hex_dest[2 + 2*CRAZY_SIZE];
hex_dest[0] = '0';
hex_dest[1] = 'x';
GET_CYCLES(x);
bin2hex(lt, &hex_dest[2], crazy_hex, CRAZY_SIZE);
GET_CYCLES(y);
printf("time=%u, ", y-x);
printf("Output: %.*s\n", 2 + 2*CRAZY_SIZE, hex_dest);
printf("***************** BIN2HEX *****************\n");
printf("***************** BIN2HEX Competition *****************\n");
size_t hex2ascii_len = 256;
char** hex2ascii;
hex2ascii = malloc(hex2ascii_len*sizeof(char*));
for(i=0; i<hex2ascii_len; i++) {
hex2ascii[i] = malloc(3*sizeof(char));
snprintf(hex2ascii[i], 3,"%02X", i);
}
size_t len = 8;
GET_CYCLES(x);
newhex_dest = char_to_hex((const unsigned char*)crazy_hex, CRAZY_SIZE, (char**)hex2ascii);
GET_CYCLES(y);
printf("time=%u, ", y-x);
printf("Output: 0x%s\n", newhex_dest);
fclose(rand_fh);
return EXIT_SUCCESS;
}
