<?xml version="1.0" encoding="UTF-8"?><!-- generator="WordPress/2.8.4" -->
<rss version="0.92">
<channel>
	<title>Nynaeve</title>
	<link>http://www.nynaeve.net</link>
	<description>Adventures in Windows debugging and reverse engineering.</description>
	<lastBuildDate>Tue, 24 Aug 2010 12:00:36 +0000</lastBuildDate>
	<docs>http://backend.userland.com/rss092</docs>
	<language>en</language>
	
	<item>
		<title>NWScript JIT engine:  Wrap-up (for now)</title>
		<description>Yesterday, I provided a brief performance overview of the MSIL JIT backend versus my implementation of an interpretive VM for various workloads.

Today, I'll mostly pontificate on conclusions from the JIT project.  It has certainly been an interesting foray into .NET, program analysis, and code generation; the JIT engine is ...</description>
		<link>http://www.nynaeve.net/?p=486</link>
			</item>
	<item>
		<title>NWScript JIT engine: Performance considerations</title>
		<description>Last time, we learned how SAVE_STATEs are supported by the MSIL JIT backend.  This time, we'll touch on everybody's favorite topic -- performance.

After all, the whole point of the JIT project is to improve performance of scripts; there wouldn't be much point in using it over the interpretive VM ...</description>
		<link>http://www.nynaeve.net/?p=483</link>
			</item>
	<item>
		<title>NWScript JIT engine: MSIL backend support for SAVE_STATE</title>
		<description>Yesterday, I described how the fast action call mechanism improves action call performance for JIT'd programs.  For today's NWScript adventure, let's dig into how SAVE_STATE operations (script situations) are supported in the MSIL JIT backend.

As you may recall, SAVE_STATE operations (codified by I_SAVE_STATE in the IR instruction set and ...</description>
		<link>http://www.nynaeve.net/?p=479</link>
			</item>
	<item>
		<title>NWScript JIT engine: JIT intrinsics, and JIT’d action service handler calls, part 4: Direct fast action calls</title>
		<description>Previously, I explained how the 'fast' action service call interface worked -- and why it doesn't always live up to its namesake.

This time, we'll examine the no-holds-barred, non-verifiable direct fast action call path.  This action service call mechanism is designed for maximum performance at the expense of type-safe, verifiable ...</description>
		<link>http://www.nynaeve.net/?p=473</link>
			</item>
	<item>
		<title>NWScript JIT engine: JIT intrinsics, and JIT&#8217;d action service handler calls, part 3: Fast action calls</title>
		<description>Yesterday, we learned how the standard action service call path operates in the MSIL JIT backend for the NWScript JIT engine.  This time, we'll examine the 'fast' action service call path.

As I alluded to last time, the fast action service call path attempts to cut down on the overhead ...</description>
		<link>http://www.nynaeve.net/?p=398</link>
			</item>
	<item>
		<title>NWScript JIT engine: JIT intrinsics, and JIT&#8217;d action service handler calls, part 2: Standard action calls</title>
		<description>Last time, I outlined the general usage of the JIT intrinsics emitted by the MSIL backend for the NWScript JIT engine, and how they relate to action service calls.  Today, let's take a closer at how an action service handler is actually called in NWScript in the wild.

The MSIL ...</description>
		<link>http://www.nynaeve.net/?p=389</link>
			</item>
	<item>
		<title>NWScript JIT engine: JIT intrinsics, and JIT&#8217;d action service handler calls, part 1</title>
		<description>Previously, I demonstrated how a simple NWScript subroutine could be translated into MSIL, and then to native instructions by the CLR JIT.  We still have a large piece of functionality to cover, however, which is calling action service handlers (extension points) from JIT'd code.  In order to understand ...</description>
		<link>http://www.nynaeve.net/?p=386</link>
			</item>
	<item>
		<title>NWScript JIT engine: Under the hood of a generated MSIL subroutine</title>
		<description>Yesterday, I expounded on the basics of how assemblies for scripts are structured, and how variables, subroutines, and IR instructions are managed throughout this process.

Nothing beats a good concrete example, though, so let's examine a sample subroutine, both in NWScript source text form, and then again in MSIL form, and ...</description>
		<link>http://www.nynaeve.net/?p=453</link>
			</item>
	<item>
		<title>NWScript JIT engine: Generating a .NET assembly for a JIT&#8217;d script</title>
		<description>Last time, I outlined the MSIL JIT backend from a high level, and described some of how its external interface functions.

While knowing how the MSIL JIT backend works from the outside is all well and good, most of the interesting parts are in the internals.  This time, let's dig ...</description>
		<link>http://www.nynaeve.net/?p=435</link>
			</item>
	<item>
		<title>NWScript JIT engine: MSIL JIT backend overview and design goals</title>
		<description>Yesterday, we examined the IR instruction raising process, at a high level.  With a basic understanding of both how the IR is generated, and the IR design itself, we can begin to talk about the JIT backends supported by the JIT system.

The first supported JIT backend is the MSIL ...</description>
		<link>http://www.nynaeve.net/?p=417</link>
			</item>
</channel>
</rss>

<!-- Dynamic Page Served (once) in 0.393 seconds -->
