Using Nios II Floating Point Custom Instructions Tutorial Tt

User Manual:

Open the PDF directly: View PDF .
Page Count: 16

Download
Open PDF In Browser	View PDF

Using Nios II Floating-Point Custom Instructions
Tutorial

101 Innovation Drive
San Jose, CA 95134
www.altera.com
TU-N2FLTNGPNT-2.0

Copyright © 2010 Altera Corporation. All rights reserved. Altera, The Programmable Solutions Company, the
stylized Altera logo, and specific device designations are trademarks and/or service marks of Altera Corporation
in the U.S. and other countries. All other words and logos identified as trademarks and/or service marks are the
property of Altera Corporation or their respective owners. Altera products are protected under numerous U.S. and
foreign patents and pending applications, maskwork rights, and copyrights. Altera warrants performance of its
semiconductor products to current specifications in accordance with Altera's standard warranty, but reserves the
right to make changes to any products and services at any time without notice. Altera assumes no responsibility or
liability arising out of the application or use of any information, product, or service described herein except as
expressly agreed to in writing by Altera. Altera customers are advised to obtain the latest version of device
specifications before relying on any published information and before placing orders for products or services.

Contents

Chapter 1. Floating-Point Custom Instructions
About the Floating-Point Custom Instructions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1–1
Preparing Your System . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1–2
Prerequisites . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1–2
Software and Hardware Requirements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1–2
Tutorial Software Files . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1–3
Building and Programming the Hardware . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1–3
Building and Running the Software . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1–4
Creating the Software Project . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1–4
Building and Running the Software and Analyzing the Results . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1–5
Software Implementation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1–6
Moving On to Your Own System . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1–7
Assessing Your Floating-Point Optimization Needs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1–7
Floating-Point Divide Considerations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1–8
Simulation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1–9
Device Resource Usage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1–9

Additional Information
Document Revision History . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Info–1
How to Contact Altera . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Info–1
Typographic Conventions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Info–1

February 2010

Altera Corporation

Using Nios II Floating-Point Custom Instructions Tutorial

iv

Using Nios II Floating-Point Custom Instructions Tutorial

Contents

February 2010 Altera Corporation

1. Floating-Point Custom Instructions

This tutorial guides you through the basics elements of floating-point custom
instructions for use with the Nios® II embedded processor. Nios II floating-point
custom instructions accelerate arithmetic functions executed on float variable types.
The tutorial is a good starting point if you are considering floating-point custom
instructions for inclusion in your own project. In this tutorial you add the floatingpoint custom instructions to a Nios II example design, and create a software program
to demonstrate floating-point performance.
The tutorial covers the following topics:
■

How to add floating-point custom instructions to a Nios II processor

■

How to use floating-point custom instructions in a C program, and how the
custom instructions work with the Nios II Embedded Design Suite (EDS)

■

The advantages and disadvantages of floating-point custom instructions, and how
best to use them in your own system

About the Floating-Point Custom Instructions
The floating-point custom instructions, optionally available on the Nios II processor,
implement single-precision, floating-point arithmetic operations. You can use the
custom instructions to accelerate floating-point operations in your Nios II C/C++
application program. The basic set of floating-point custom instructions is available
on every Nios II core implementation and includes single precision floating-point
addition, subtraction, and multiplication. Floating-point division is available as an
extension to the basic instruction set.
Table 1–1 lists approximate acceleration factors that the floating-point custom
instructions provide:
Table 1–1. Sample Floating-Point Custom Instruction Acceleration Factors (Note 1)
Target Device

Addition

Subtraction

Multiplication

Division

EP3C120

20 times

18 times

17 times

12 times

EP3SL150

18 times

19 times

12 times

13 times

Note to Table 1–1:
(1) These figures show typical speed increases over the equivalent software implementation. For each target
device, these results were obtained using a Nios II /f core processor executing code from on-chip memory.
You might see different acceleration results, depending on your hardware design and target device and on the
details of your software application.

When the floating-point custom instructions are present in your target hardware, the
Nios II Software Build Tools (SBT) for Eclipse compiles your code to use the custom
instructions for floating-point operations, including the four primitive arithmetic
operations (addition, subtraction, multiplication and division) and the ANSI C math
library. Table 1–2 on page 1–8 lists the ANSI C math functions.

February 2010

Altera Corporation

Using Nios II Floating-Point Custom Instructions Tutorial

1–2

Chapter 1: Floating-Point Custom Instructions
Preparing Your System

f The floating point custom instructions substantially comply with the IEEE 754-1985
floating point standard. For details, refer to “Floating Point Instructions” in the
Processor Architecture chapter of the Nios II Processor Reference Handbook.

Preparing Your System
The following sections provide information you need before you begin the tutorial.

Prerequisites
To make effective use of this tutorial, you should be familiar with the following topics:
■

Defining and generating Nios II hardware systems with SOPC Builder

■

Compiling Nios II hardware systems with the Quartus® II development software

■

Creating, compiling, and running Nios II software projects

f To learn about defining, generating, and compiling Nios II systems, refer to the Nios II
Hardware Development Tutorial. To learn about Nios II software projects, refer to the
Getting Started with the Graphical User Interface chapter of the Nios II Software
Developer’s Handbook.

Software and Hardware Requirements
This tutorial requires the following software and hardware:
■

Quartus II development software version 9.1 or later, installed on a Windows or
Linux computer

■

Nios II EDS version 9.1 or later

■

A JTAG download cable compatible with your target hardware, for example, a
USB-Blaster™ cable

■

A development board that includes the following devices:
■

An Altera FPGA large enough to support the Nios II processor core, hold the
target design, and leave enough unused logic elements to support the floatingpoint custom instructions. For information about device resource usage, refer
to Table 1–3 on page 1–9.

■

An oscillator that drives a constant clock frequency to an FPGA pin. The
maximum frequency depends on the speed grade of the FPGA.

■

A JTAG connection to the FPGA that provides a programming interface and
communication link to the Nios II system. This connection can be either a
dedicated 10-pin JTAG header for an Altera USB-Blaster download cable
(revision B or higher) or a USB connection with USB-Blaster circuitry
embedded on the board.

Using Nios II Floating-Point Custom Instructions Tutorial

February 2010 Altera Corporation

Chapter 1: Floating-Point Custom Instructions
Building and Programming the Hardware

■

1–3

A Nios II target design that includes the following components:
■

Nios II processor

■

JTAG UART

■

Performance counter with at least 2 simultaneously-measured sections

■

128 KB of on-chip or external memory

■

System timer

■

System ID peripheral

f Altera provides several working Nios II reference designs which you can use as a
starting point for your own designs. After installing the Nios II EDS, refer to the
/examples/verilog or the /examples/vhdl directory. Demonstration applications are also available in
newer development kit installations.

Tutorial Software Files
The tutorial software files are available in a .zip file next to the link to this document
on the Literature: Nios II Processor page of the Altera website. Download and unzip
the file in a temporary directory. The .zip file includes the following files:
■

floating_point.c—main program

■

floating_point.h—global definitions

■

floating_point_CI.c—functions to exercise the floating-point custom instructions

■

floating_point_SW.c—functions to exercise the software-implemented floatingpoint operations

Building and Programming the Hardware
Perform the following steps to add the floating-point custom instructions to the
Nios II processor in your target design:
1. Start the Quartus II development software and open a working copy of your target
design.
2. Start SOPC Builder.
3. On the System Contents tab, double-click the Nios II processor component. The
Nios II MegaWizard interface appears.
4. Select the Custom Instructions page.
5. Select Floating Point Hardware from the list and click Add. The Nios II Floating
Point Hardware dialog box appears.
6. Turn on Use floating point division hardware.
1

February 2010

Altera Corporation

The floating-point division hardware is optional. For a discussion regarding
the advantages and disadvantages of using the floating-point division
hardware, refer to “Moving On to Your Own System” on page 1–7.

Using Nios II Floating-Point Custom Instructions Tutorial

1–4

Chapter 1: Floating-Point Custom Instructions
Building and Running the Software

7. Click Finish to exit the Nios II Floating Point Hardware dialog box. Figure 1–1
shows the Custom Instructions page of the Nios II MegaWizard interface with the
floating-point hardware inserted.
Figure 1–1. Hardware Setup Dialog Box

f For further information about adding the floating-point custom
instructions, refer to the Instantiating the Nios II Processor in SOPC Builder
chapter of the Nios II Processor Reference Handbook.
8. Click Finish to exit the Nios II MegaWizard interface.
9. Generate the HDL for your SOPC Builder system. When the generation process is
complete, exit SOPC Builder.
10. Compile the Quartus II project.
11. Program your target hardware with the resulting SRAM Object File (.sof).

Building and Running the Software
This section steps you through creating, building, running, and analyzing your
software project.

Creating the Software Project
Perform the following steps to create the software project:
1. Start the Nios II SBT for Eclipse.
2. Create a new Nios II Application and BSP from Template based on the Blank
Project template. Under Target hardware information, browse to locate the SOPC
Information File (.sopcinfo) that you generated in “Building and Programming
the Hardware” on page 1–3.

Using Nios II Floating-Point Custom Instructions Tutorial

February 2010 Altera Corporation

Chapter 1: Floating-Point Custom Instructions
Building and Running the Software

1–5

3. Import the tutorial software files described in “Tutorial Software Files” on
page 1–3 into your Nios II application project. The easiest way to do this is to select
the files in an application such as Windows Explorer, and drag them into the
Nios II application project folder in the Project Explorer view of the Nios II SBT for
Eclipse.
4. Adjust the compiler optimization settings to meet your needs. Access the settings
through the Properties dialog boxes for your Nios II application and Nios II BSP
projects.

Building and Running the Software and Analyzing the Results
Perform the following steps to analyze the results of the software project:
1. Build the software project. The Nios II SBT for Eclipse detects the presence of the
floating-point custom instructions at build time, and uses them for all single
precision floating-point arithmetic.
2. Run the software on your Nios II target design. The program runs four tests, one
each for the add, subtract, multiply, and divide operations. In each test, the
program carries out the floating-point operation on 1000 pairs of random
operands. It executes both the floating-point custom instruction and the
equivalent software implementation. Using the performance counter component,
the tutorial software compares the hardware and software execution times.
The following program output shows the results:
--Performance Counter Report-Total Time: 0.01222420 seconds

(611210 clock-cycles)

+---------------+-----+-----------+---------------+-----------+
| Section

|

%

| Time (sec)|

Time (clocks)|Occurrences|

+---------------+-----+-----------+---------------+-----------+
|FP CI ADD

| 2.29|

0.00030|

14000|

1000|

+---------------+-----+-----------+---------------+-----------+
|FP SW ADD

| 50.2|

0.00610|

306640|

1000|

+---------------+-----+-----------+---------------+-----------+

--Performance Counter Report-Total Time: 0.00987798 seconds

(493899 clock-cycles)

+---------------+-----+-----------+---------------+-----------+
| Section

|

%

| Time (sec)|

Time (clocks)|Occurrences|

+---------------+-----+-----------+---------------+-----------+
|FP CI SUBTRACT | 2.83|

0.00028|

14000|

1000|

+---------------+-----+-----------+---------------+-----------+
|FP SW SUBTRACT | 50.8|

0.00502|

250975|

1000|

+---------------+-----+-----------+---------------+-----------+

February 2010

Altera Corporation

Using Nios II Floating-Point Custom Instructions Tutorial

1–6

Chapter 1: Floating-Point Custom Instructions
Building and Running the Software

--Performance Counter Report-Total Time: 0.0110131 seconds

(550654 clock-cycles)

+---------------+-----+-----------+---------------+-----------+
| Section

|

%

| Time (sec)|

Time (clocks)|Occurrences|

+---------------+-----+-----------+---------------+-----------+
|FP CI MULTIPLY | 2.18|

0.00024|

12000|

1000|

+---------------+-----+-----------+---------------+-----------+
|FP SW MULTIPLY |

59|

0.00650|

325076|

1000|

+---------------+-----+-----------+---------------+-----------+

--Performance Counter Report-Total Time: 0.0142152 seconds

(710758 clock-cycles)

+---------------+-----+-----------+---------------+-----------+
| Section

|

%

| Time (sec)|

Time (clocks)|Occurrences|

+---------------+-----+-----------+---------------+-----------+
|FP CI DIVIDE

|

4.5|

0.00064|

32000|

1000|

+---------------+-----+-----------+---------------+-----------+
|FP SW DIVIDE

| 67.8|

0.00963|

481698|

1000|

+---------------+-----+-----------+---------------+-----------+

3. Analyze the results report for each test. In each report, the FP CI
 entry lists the performance of the custom instruction, and the
FP SW  entry lists the performance of the software
implementation. The Time (sec) and Time (clock) columns represent the
aggregate time spent executing the floating-point operations, in seconds and in
Nios II clock cycles. Total Time represents the duration of the test, expressed
both in seconds and in Nios II clock cycles. The % column represents the time spent
executing the floating-point operation, as a percentage of the test total.
1

You might have different speed results, depending on your target hardware
and on the actual values of the random operands.

f The tutorial software uses the Nios II performance counter component to collect
timing information on the floating-point operations. For more information, refer to
the Performance Counter Core chapter in volume 5 of the Quartus II Handbook.

Software Implementation
The tutorial software uses #pragma directives to compare hardware and software
implementations of the floating-point instructions.
The following #pragmas direct the Nios II compiler to ignore the floating-point
instructions and generate software implementations:
■

#pragma no_custom_fadds—forces software implementation of floating-point
add

Using Nios II Floating-Point Custom Instructions Tutorial

February 2010 Altera Corporation

Chapter 1: Floating-Point Custom Instructions
Moving On to Your Own System

1–7

■

#pragma no_custom_fsubs—forces software implementation of floating-point
subtract

■

#pragma no_custom_fmuls—forces software implementation of floating-point
multiply

■

#pragma no_custom_fdivs—forces software implementation of floating-point
divide

The scope of these #pragmas is the entire C file.
f For more information, refer to “Floating Point Instructions” in the Processor
Architecture chapter of the Nios II Processor Reference Handbook.

Moving On to Your Own System
Congratulations! You have successfully created a Nios II system that uses the floatingpoint custom instructions. Through this tutorial, you have familiarized yourself with
the following steps for integrating the floating-point custom instructions into a Nios II
system:
■

Modifying and generating Nios II system hardware in SOPC Builder

■

Compiling the Quartus II project

■

Creating a new project in the Nios II SBT for Eclipse

■

Compiling the project

■

Running the software on the target hardware

This section helps you determine how to use the floating-point custom instructions in
your own project.

Assessing Your Floating-Point Optimization Needs
The best choice for your hardware design depends on a balance among floating-point
usage, hardware resource usage, and performance. While the floating-point custom
instructions speed up floating-point arithmetic, they add substantially to the size of
your hardware project. If resource usage is an issue, before using the floating-point
custom instructions, consider the following questions:
■

Have you identified your performance bottlenecks? Make sure your performance
issues are caused by floating-point arithmetic before you try to fix them with
floating-point acceleration.
f For detailed information about Nios II performance profiling, refer to
AN391: Profiling Nios II Systems.

■

February 2010

Can you use integer arithmetic? While the floating-point custom instructions are
faster than software-implemented floating-point, they are slower than integer
arithmetic. A common integer technique is to represent numerical values with an
implicit scaling factor. As a simple example, if you are calculating milliamperes,
you might represent your values internally as microamperes.

Altera Corporation

Using Nios II Floating-Point Custom Instructions Tutorial

1–8

Chapter 1: Floating-Point Custom Instructions
Moving On to Your Own System

■

Are you taking full advantage of compiler optimization? You can increase the
Nios II compiler optimization level through the Properties dialog box of your
Nios II application and BSP projects.
f For information, refer to “Reducing Code Footprint” in the Developing
Programs Using the Hardware Abstraction Layer chapter of the Nios II Software
Developer’s Handbook.

■

Have you hand-optimized your mathematical operations? Numerical analysis
textbooks offer simple, effective techniques for performing accurate calculations
with the minimum number of floating-point operations.

If you have followed these suggestions, and you need further acceleration, the
floating-point custom instructions are probably an appropriate solution.

Floating-Point Divide Considerations
The floating-point division hardware requires more resources than the other
instructions, so you might opt to omit it if your Nios II application does not make
heavy use of floating-point division.
In some cases, you can rewrite your code to minimize or even eliminate divide
operations. For example, if your algorithm requires division by a constant value, you
can precalculate its inverse and use a multiply operation in the speed-critical section
of your code.
Table 1–2 indicates which math library functions use floating-point, and of those,
which use floating-point division. If a function uses floating-point, it runs faster with
floating-point hardware. If a function uses floating-point division, it runs even faster
with floating-point division hardware.
Table 1–2. Math Library Floating-Point Usage
Math
Function

Uses Floating- Uses FloatingPoint
Point Division

Math
Function

Uses Floating- Uses FloatingPoint
Point Division

acos()

Yes

Yes

frexp()

Yes

asin()

Yes

Yes

ldexp()

Yes

atan()

Yes

Yes

log()

Yes

Yes

atan2()

Yes

Yes

log10()

Yes

Yes

cos()

Yes

modf()

Yes

cosh()

Yes

pow()

Yes

Yes

sin()

Yes

sqrt()

Yes

Yes

sinh()

Yes

Yes

ceil()

Yes

tan()

Yes

Yes

fabs()

tanh()

Yes

Yes

floor()

Yes

exp()

Yes

Yes

fmod()

Yes

Yes

Yes

When you omit the floating-point divide instruction, the Nios II SBT for Eclipse
implements floating-point division in software.

Using Nios II Floating-Point Custom Instructions Tutorial

February 2010 Altera Corporation

Chapter 1: Floating-Point Custom Instructions
Moving On to Your Own System

1–9

f For information about selecting the floating-point division hardware with the Nios II
MegaWizard interface, refer to the Instantiating the Nios II Processor in SOPC Builder
chapter of the Nios II Processor Reference Handbook.

Simulation
You can use the floating-point custom instructions with the ModelSim hardware
simulator.

Device Resource Usage
The floating-point custom instructions are available on all Altera devices that support
the Nios II processor. Table 1–3 shows approximate resource usage in each supported
device.
If the target device includes on-chip multiplier elements, the floating-point hardware
incorporates them as needed. If there are no on-chip multiplier elements, the floatingpoint custom instructions are implemented entirely with general-purpose logic
elements.
Table 1–3. Approximate Device Resource Usage

Target Device Family

Logic Elements (LE) or
Adaptive Look-up Tables (ALUT)

Multiplier
Elements (1)

Without Divide

With Divide

Cyclone III

1500 LEs

7200 LEs

7

Stratix III

750 ALUTs

4200 ALUTs

4

Note to Table 1–3:
(1) In Cyclone III devices, the multiplier element is an embedded multiplier 9-bit element. In Stratix III devices, the
multiplier element is a DSP 18-bit element.

1

February 2010

Depending on the Quartus II routing and fitting, resource usage in your project might
differ considerably from the values shown in Table 1–3.

Altera Corporation

Using Nios II Floating-Point Custom Instructions Tutorial

1–10

Using Nios II Floating-Point Custom Instructions Tutorial

Chapter 1: Floating-Point Custom Instructions
Moving On to Your Own System

February 2010 Altera Corporation

Additional Information

Document Revision History
The following table shows the revision history for this document.
Date

Version

Changes

February 2010

2.0

Revised for Nios II Software Build Tools for Eclipse.

May 2006

1.0

Initial release.

How to Contact Altera
For the most up-to-date information about Altera products, refer to the following
table.

Contact (1)
Technical support
Technical training

Contact
Method

Address

Website

www.altera.com/support

Website

www.altera.com/training

Email

custrain@altera.com

Product literature

Website

www.altera.com/literature

Non-technical support (General)

Email

nacomp@altera.com

(Software Licensing)

Email

authorization@altera.com

Note to Table:
(1) You can also contact your local Altera sales office or sales representative.

Typographic Conventions
The following table shows the typographic conventions this document uses.
Visual Cue

Meaning

Bold Type with Initial Capital
Letters

Indicates command names, dialog box titles, dialog box options, and other GUI
labels. For example, Save As dialog box. For GUI elements, capitalization matches the
GUI.

bold type

Indicates directory names, project names, disk drive names, file names, file name
extensions, software utility names, and GUI labels. For example, \qdesigns directory,
d: drive, and chiptrip.gdf file.

Italic Type with Initial Capital Letters

Indicates document titles. For example, AN 519: Stratix IV Design Guidelines.
Indicates variables. For example, n + 1.

Italic type

Variable names are enclosed in angle brackets (< >). For example,  and
.pof file.

Initial Capital Letters

February 2010

Altera Corporation

Indicates keyboard keys and menu names. For example, the Delete key and the
Options menu.

Using Nios II Floating-Point Custom Instructions Tutorial

Info–2

Additional Information
Typographic Conventions

Visual Cue
“Subheading Title”

Meaning
Quotation marks indicate references to sections within a document and titles of
Quartus II Help topics. For example, “Typographic Conventions.”
Indicates signal, port, register, bit, block, and primitive names. For example, data1,
tdi, and input. The suffix n denotes an active-low signal. For example, resetn.

Courier type

Indicates command line commands and anything that must be typed exactly as it
appears. For example, c:\qdesigns\tutorial\chiptrip.gdf.
Also indicates sections of an actual file, such as a Report File, references to parts of
files (for example, the AHDL keyword SUBDESIGN), and logic function names (for
example, TRI).

1., 2., 3., and
a., b., c., and so on

Numbered steps indicate a list of items when the sequence of the items is important,
such as the steps listed in a procedure.

■ ■

Bullets indicate a list of items when the sequence of the items is not important.

■

1

The hand points to information that requires special attention.

c

A caution calls attention to a condition or possible situation that can damage or
destroy the product or your work.

w

A warning calls attention to a condition or possible situation that can cause you
injury.

r

The angled arrow instructs you to press the Enter key.

f

The feet direct you to more information about a particular topic.

Using Nios II Floating-Point Custom Instructions Tutorial

February 2010 Altera Corporation



---

Source Exif Data:

File Type                       : PDF
File Type Extension             : pdf
MIME Type                       : application/pdf
PDF Version                     : 1.4
Linearized                      : Yes
Tagged PDF                      : Yes
XMP Toolkit                     : Adobe XMP Core 4.2.1-c043 52.372728, 2009/01/18-15:08:04
Format                          : application/pdf
Title                           : Using Nios II Floating-Point Custom Instructions Tutorial
Creator                         : Altera Coproration
Description                     : This tutorial introduces you to floating-point custom instructions in the Nios II processor.
Create Date                     : 2010:02:05 15:35:34Z
Modify Date                     : 2010:02:05 16:08:46-08:00
Creator Tool                    : FrameMaker 9.0
Metadata Date                   : 2010:02:05 16:08:46-08:00
Producer                        : Acrobat Distiller 9.3.0 (Windows)
Copyright                       : (c) 2010 Altera Corporation
Web Statement                   : This tutorial introduces you to floating-point custom instructions in the Nios II processor.
Document ID                     : uuid:04bde142-52e1-4bdd-9cde-abf6dc93dc77
Instance ID                     : uuid:0bb1facb-528e-49de-b93c-974a99c1251c
Page Mode                       : UseOutlines
Page Count                      : 16
Author                          : Altera Coproration
Keywords                        : FPGA, floating-point, custom instructions, development board, starter board, simple design
Subject                         : This tutorial introduces you to floating-point custom instructions in the Nios II processor.

EXIF Metadata provided by EXIF.tools