ViewVC Help

View File | Revision Log | Show Annotations | Revision Graph | Root Listing

root/cebix/BasiliskII/src/Unix/main_unix.cpp

Comparing BasiliskII/src/Unix/main_unix.cpp (file contents):
Revision 1.66 by gbeauche, 2005-06-06T19:39:36Z vs.
Revision 1.72 by gbeauche, 2006-02-27T07:24:58Z

#	Line 223 | Line 223 | char *strdup(const char *s)
223
224
225		/*
226	<	*  Map memory that can be accessed from the Mac side
226	>	*  Helpers to map memory that can be accessed from the Mac side
227		*/
228
229	+	// NOTE: VM_MAP_33BIT is only used when compiling a 64-bit JIT on specific platforms
230		void *vm_acquire_mac(size_t size)
231		{
232		void *m = vm_acquire(size, VM_MAP_DEFAULT | VM_MAP_33BIT);
233	<	if (m == NULL) {
233	>	#ifdef USE_33BIT_ADDRESSING
234	>	if (m == VM_MAP_FAILED) {
235	>	printf("WARNING: Cannot acquire memory in 33-bit address space (%s)\n", strerror(errno));
236		ThirtyThreeBitAddressing = false;
237		m = vm_acquire(size);
238		}
239	+	#endif
240		return m;
241		}
242
243	+	static int vm_acquire_mac_fixed(void *addr, size_t size)
244	+	{
245	+	int ret = vm_acquire_fixed(addr, size, VM_MAP_DEFAULT | VM_MAP_33BIT);
246	+	#ifdef USE_33BIT_ADDRESSING
247	+	if (ret < 0) {
248	+	printf("WARNING: Cannot acquire fixed memory in 33-bit address space (%s)\n", strerror(errno));
249	+	ThirtyThreeBitAddressing = false;
250	+	ret = vm_acquire_fixed(addr, size);
251	+	}
252	+	#endif
253	+	return ret;
254	+	}
255	+
256
257		/*
258		*  SIGSEGV handler
#	Line 292 | Line 309 | static void sigsegv_dump_state(sigsegv_a
309
310
311		/*
312	+	*  Update virtual clock and trigger interrupts if necessary
313	+	*/
314	+
315	+	#ifdef USE_CPU_EMUL_SERVICES
316	+	static uint64 n_check_ticks = 0;
317	+	static uint64 emulated_ticks_start = 0;
318	+	static uint64 emulated_ticks_count = 0;
319	+	static int64 emulated_ticks_current = 0;
320	+	static int32 emulated_ticks_quantum = 1000;
321	+	int32 emulated_ticks = emulated_ticks_quantum;
322	+
323	+	void cpu_do_check_ticks(void)
324	+	{
325	+	#if DEBUG
326	+	n_check_ticks++;
327	+	#endif
328	+
329	+	uint64 now;
330	+	static uint64 next = 0;
331	+	if (next == 0)
332	+	next = emulated_ticks_start = GetTicks_usec();
333	+
334	+	// Update total instructions count
335	+	if (emulated_ticks <= 0) {
336	+	emulated_ticks_current += (emulated_ticks_quantum - emulated_ticks);
337	+	// XXX: can you really have a machine fast enough to overflow
338	+	// a 63-bit m68k instruction counter within 16 ms?
339	+	if (emulated_ticks_current < 0) {
340	+	printf("WARNING: Overflowed 63-bit m68k instruction counter in less than 16 ms!\n");
341	+	goto recalibrate_quantum;
342	+	}
343	+	}
344	+
345	+	// Check for interrupt opportunity
346	+	now = GetTicks_usec();
347	+	if (next < now) {
348	+	one_tick();
349	+	do {
350	+	next += 16625;
351	+	} while (next < now);
352	+	emulated_ticks_count++;
353	+
354	+	// Recalibrate 1000 Hz quantum every 10 ticks
355	+	static uint64 last = 0;
356	+	if (last == 0)
357	+	last = now;
358	+	else if (now - last > 166250) {
359	+	recalibrate_quantum:
360	+	emulated_ticks_quantum = ((uint64)emulated_ticks_current * 1000) / (now - last);
361	+	emulated_ticks_current = 0;
362	+	last = now;
363	+	}
364	+	}
365	+
366	+	// Update countdown
367	+	if (emulated_ticks <= 0)
368	+	emulated_ticks += emulated_ticks_quantum;
369	+	}
370	+	#endif
371	+
372	+
373	+	/*
374		*  Main program
375		*/
376
#	Line 450 | Line 529 | int main(int argc, char **argv)
529		WarningAlert(GetString(STR_SMALL_RAM_WARN));
530		RAMSize = 1024*1024;
531		}
532	+	if (RAMSize > 1023*1024*1024)                                           // Cap to 1023MB (APD crashes at 1GB)
533	+	RAMSize = 1023*1024*1024;
534
535		#if REAL_ADDRESSING || DIRECT_ADDRESSING
536		RAMSize = RAMSize & -getpagesize();                                     // Round down to page boundary
#	Line 458 | Line 539 | int main(int argc, char **argv)
539		// Initialize VM system
540		vm_init();
541
542	+	#ifdef USE_33BIT_ADDRESSING
543	+	// Speculatively enables 33-bit addressing
544	+	ThirtyThreeBitAddressing = true;
545	+	#endif
546	+
547		#if REAL_ADDRESSING
548		// Flag: RAM and ROM are contigously allocated from address 0
549		bool memory_mapped_from_zero = false;
550	<
551	<	// Under Solaris/SPARC and NetBSD/m68k, Basilisk II is known to crash
552	<	// when trying to map a too big chunk of memory starting at address 0
553	<	#if defined(OS_solaris) || defined(OS_netbsd) || defined(PAGEZERO_HACK)
554	<	const bool can_map_all_memory = false;
469	<	#else
550	>
551	>	// Make sure to map RAM & ROM at address 0 only on platforms that
552	>	// supports linker scripts to relocate the Basilisk II executable
553	>	// above 0x70000000
554	>	#if HAVE_LINKER_SCRIPT
555		const bool can_map_all_memory = true;
556	+	#else
557	+	const bool can_map_all_memory = false;
558		#endif
559
560		// Try to allocate all memory from 0x0000, if it is not known to crash
561	<	if (can_map_all_memory && (vm_acquire_fixed(0, RAMSize + 0x100000) == 0)) {
561	>	if (can_map_all_memory && (vm_acquire_mac_fixed(0, RAMSize + 0x100000) == 0)) {
562		D(bug("Could allocate RAM and ROM from 0x0000\n"));
563		memory_mapped_from_zero = true;
564		}
565
566		#ifndef PAGEZERO_HACK
567		// Otherwise, just create the Low Memory area (0x0000..0x2000)
568	<	else if (vm_acquire_fixed(0, 0x2000) == 0) {
568	>	else if (vm_acquire_mac_fixed(0, 0x2000) == 0) {
569		D(bug("Could allocate the Low Memory globals\n"));
570		lm_area_mapped = true;
571		}
#	Line 501 | Line 588 | int main(int argc, char **argv)
588		else
589		#endif
590		{
591	<	#ifdef USE_33BIT_ADDRESSING
592	<	// Speculatively enables 33-bit addressing
506	<	ThirtyThreeBitAddressing = true;
507	<	#endif
508	<	RAMBaseHost = (uint8 *)vm_acquire_mac(RAMSize);
509	<	ROMBaseHost = (uint8 *)vm_acquire_mac(0x100000);
510	<	if (RAMBaseHost == VM_MAP_FAILED || ROMBaseHost == VM_MAP_FAILED) {
591	>	uint8 *ram_rom_area = (uint8 *)vm_acquire_mac(RAMSize + 0x100000);
592	>	if (ram_rom_area == VM_MAP_FAILED) {
593		ErrorAlert(STR_NO_MEM_ERR);
594		QuitEmulator();
595		}
596	+	RAMBaseHost = ram_rom_area;
597	+	ROMBaseHost = RAMBaseHost + RAMSize;
598		}
599
600		#if USE_SCRATCHMEM_SUBTERFUGE
601		// Allocate scratch memory
602	<	ScratchMem = (uint8 *)vm_acquire(SCRATCH_MEM_SIZE);
602	>	ScratchMem = (uint8 *)vm_acquire_mac(SCRATCH_MEM_SIZE);
603		if (ScratchMem == VM_MAP_FAILED) {
604		ErrorAlert(STR_NO_MEM_ERR);
605		QuitEmulator();
#	Line 530 | Line 614 | int main(int argc, char **argv)
614		ROMBaseMac = Host2MacAddr(ROMBaseHost);
615		#endif
616		#if REAL_ADDRESSING
617	<	RAMBaseMac = (uint32)RAMBaseHost;
618	<	ROMBaseMac = (uint32)ROMBaseHost;
617	>	RAMBaseMac = Host2MacAddr(RAMBaseHost);
618	>	ROMBaseMac = Host2MacAddr(ROMBaseHost);
619		#endif
620		D(bug("Mac RAM starts at %p (%08x)\n", RAMBaseHost, RAMBaseMac));
621		D(bug("Mac ROM starts at %p (%08x)\n", ROMBaseHost, ROMBaseMac));
#	Line 652 | Line 736 | int main(int argc, char **argv)
736		sigaction(SIGINT, &sigint_sa, NULL);
737		#endif
738
739	+	#ifndef USE_CPU_EMUL_SERVICES
740		#if defined(HAVE_PTHREADS)
741
742		// POSIX threads available, start 60Hz thread
#	Line 715 | Line 800 | int main(int argc, char **argv)
800		setitimer(ITIMER_REAL, &req, NULL);
801
802		#endif
803	+	#endif
804
805	<	#ifdef HAVE_PTHREADS
805	>	#ifdef USE_PTHREADS_SERVICES
806		// Start XPRAM watchdog thread
807		memcpy(last_xpram, XPRAM, XPRAM_SIZE);
808		xpram_thread_active = (pthread_create(&xpram_thread, NULL, xpram_func, NULL) == 0);
#	Line 745 | Line 831 | void QuitEmulator(void)
831		Exit680x0();
832		#endif
833
834	<	#if defined(HAVE_PTHREADS)
834	>	#if defined(USE_CPU_EMUL_SERVICES)
835	>	// Show statistics
836	>	uint64 emulated_ticks_end = GetTicks_usec();
837	>	D(bug("%ld ticks in %ld usec = %f ticks/sec [%ld tick checks]\n",
838	>	(long)emulated_ticks_count, (long)(emulated_ticks_end - emulated_ticks_start),
839	>	emulated_ticks_count * 1000000.0 / (emulated_ticks_end - emulated_ticks_start), (long)n_check_ticks));
840	>	#elif defined(USE_PTHREADS_SERVICES)
841		// Stop 60Hz thread
842		if (tick_thread_active) {
843		tick_thread_cancel = true;
#	Line 764 | Line 856 | void QuitEmulator(void)
856		setitimer(ITIMER_REAL, &req, NULL);
857		#endif
858
859	<	#ifdef HAVE_PTHREADS
859	>	#ifdef USE_PTHREADS_SERVICES
860		// Stop XPRAM watchdog thread
861		if (xpram_thread_active) {
862		xpram_thread_cancel = true;
#	Line 780 | Line 872 | void QuitEmulator(void)
872
873		// Free ROM/RAM areas
874		if (RAMBaseHost != VM_MAP_FAILED) {
875	<	vm_release(RAMBaseHost, RAMSize);
875	>	vm_release(RAMBaseHost, RAMSize + 0x100000);
876		RAMBaseHost = NULL;
785	–	}
786	–	if (ROMBaseHost != VM_MAP_FAILED) {
787	–	vm_release(ROMBaseHost, 0x100000);
877		ROMBaseHost = NULL;
878		}
879
#	Line 1021 | Line 1110 | static void xpram_watchdog(void)
1110		}
1111		}
1112
1113	<	#ifdef HAVE_PTHREADS
1113	>	#ifdef USE_PTHREADS_SERVICES
1114		static void *xpram_func(void *arg)
1115		{
1116		while (!xpram_thread_cancel) {
#	Line 1046 | Line 1135 | static void one_second(void)
1135		SetInterruptFlag(INTFLAG_1HZ);
1136		TriggerInterrupt();
1137
1138	<	#ifndef HAVE_PTHREADS
1138	>	#ifndef USE_PTHREADS_SERVICES
1139		static int second_counter = 0;
1140		if (++second_counter > 60) {
1141		second_counter = 0;
#	Line 1063 | Line 1152 | static void one_tick(...)
1152		one_second();
1153		}
1154
1155	<	#if !defined(HAVE_PTHREADS) && !defined(USE_SDL_VIDEO)
1156	<	// No threads available, perform video refresh and networking from here
1155	>	#ifndef USE_PTHREADS_SERVICES
1156	>	// Threads not used to trigger interrupts, perform video refresh from here
1157		VideoRefresh();
1158	+	#endif
1159	+
1160	+	#ifndef HAVE_PTHREADS
1161	+	// No threads available, perform networking from here
1162		SetInterruptFlag(INTFLAG_ETHER);
1163		#endif
1164
#	Line 1076 | Line 1169 | static void one_tick(...)
1169		}
1170		}
1171
1172	<	#ifdef HAVE_PTHREADS
1172	>	#ifdef USE_PTHREADS_SERVICES
1173		static void *tick_func(void *arg)
1174		{
1175		uint64 start = GetTicks_usec();
#	Line 1093 | Line 1186 | static void *tick_func(void *arg)
1186		ticks++;
1187		}
1188		uint64 end = GetTicks_usec();
1189	<	D(bug("%Ld ticks in %Ld usec = %f ticks/sec\n", ticks, end - start, ticks * 1000000.0 / (end - start)));
1189	>	D(bug("%lld ticks in %lld usec = %f ticks/sec\n", ticks, end - start, ticks * 1000000.0 / (end - start)));
1190		return NULL;
1191		}
1192		#endif

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines
>	Changed lines