happy synchronisation…

Needed download: OpenSPARC T1 Core
Useful Documentation: quick start

After copying the OpenSPARCT1_1_7_os_boot.ace file into a free revN directory on the CF card and configure SW3 dips to the corresponding revN directory the board could be power-on. On the serial line the firmware boot shows up and after entering into the OpenBoot prompt OpenSolaris can be boot with the command “boot -mverbose”. Now it’s time to take a coffee, since the boot procedure takes roundabout 60 minutes. After finishing the boot procedure, a login prompt is displayed and it can be logged in the system to adjust the IP address for the local network. Now telnet can be used to log-in and to explore the system…

/sbin/fxload -v -t fx2 -I /usr/share/xusb_xlp.hex -D /proc/bus/usb/<bus>/<dev>

To get somehow familiar with the framework, I wrote a simple memcpy program which copies from host memory to device memory and vice versa. The results are quite nice.

Host to Device: 2149.465255 Mbyte/s
Device to Host: 1609.497326 Mbyte/s

In detail, the program allocates pinned memory on host side and global memory space on device side and the measurement only measures the time of the copy routine.

The next simple experiment was to lunch a so called kernel (program on the GPU). For the experiment I just copied an initialized memory region to the global device memory, did a floating point multiplication and copied the result back into host memory. To compare the measured time I did the same multiplication with the host CPU on an equal region of memory.

GPU w/out memcpy: 1.796128 ms
Host CPU        : 3.556544 ms

Hardware used: Lenovo T61p, Nvidia Quadro FX 570M.

function len(x: integer) return integer is
begin
  if (x<=1) then return 1;
  else return 1+len(x/2);
  end if;
end len;

(1) b <= a and (not a)+1;

This equation isolate the least significant bit. Since we just want to know if there are more than one bit is active, the next step is to mask out (2) the detected bit from (1) and compare the result with zero (3). If the result is zero, no other bit was active.

(2) c <= not b and a;
(3) morebits <= '0' when c = 0 else '1';

Assumption
Incoming signals “req”/”ack”, outgoing signal “grant”.

Needed Behaviour
req = “0001000″ => grant = “0001000″ -ACK- grant = “0001000″
req = “0011000″ => grant = “0010000″ -ACK- grant = “0001000″ -ACK- grant = “0010000″ …

Technique
To create a priority arbiter, we just calculate the two’s complement of the request signal and bitwise AND the result with the request line (1). As result the least significant bit has the highest priority. This equation always returns the request with the highest priority.

(1) gnt <= req and not(req)+1;

To create a round robin arbiter we have to save the previous grant signal. We use this signal to masked out the previous grant signal (2) and use the method from (1) to get the least significant active bit.

(2) reqs <= req and not ((pre_gntM - 1) or pre_gntM);
(1) gnts <= reqs and not(reqs)+1;

The last step to implement the RR-Arbiter is to select between “gnt” and “gnts” (3). If all previous grant signals are masked we just start with the highest priority of equation (1).

(3) gntM <= gnts when reqs /= 0 else gnt;

Conclusion
This technique can be used to create a round robin arbiter for any number of input bits. Only one parameter must be changed so increase/decrease inputs and outputs.

[update 2010] Since I got some requests, Round Robin Arbiter.

[1] http://stackoverflow.com/questions/480405/finding-the-next-in-round-robin-scheduling-by-bit-twiddling