Cyclops64 is part of the 

Blue Gene effort, to produce the next several generations of supercomputers.

The projects were started in response to the announced construction of the Earth Simulator.

Cyclops64 is a cooperative project between the United States Department of Energy (which is

partially funding the project), the U.S. Department of Defense, industry (IBM in particular),
and academia.

The architecture was conceived by Cray award winner Monty Denneau, who is currently leading the
project.

[edit]Architecture overview
Each 64-bit Cyclops64 chip (processor) will run at 500 megahertz and contain 80 processors. Each
processor will have two thread units and a floating point unit. A thread unit is an in-order 64-
bit RISC core with 32 kB scratch pad memory, using a 60-instruction subset of the Power
Architecture instruction set. Five processors share a 32 kB instruction cache.

The processors will be connected with a 96 port, 7 stage non-internally blocking crossbar switch. They
will communicate with each other via global interleaved memory (memory that can be written to and
read by all threads) in the SRAM.

The theoretical peak performance of a Cyclops64 chip is 80 gigaflops (this assumes a continuous

stream of Multiply-accumulate instructions, each of which are counted as two floating point
operations). A full system (consisting of 2 thread units per processor, 80 processors per chip, 1 chip
per board, 48 boards per midplane, 3 midplanes per rack, and 96 (12 x 8) racks per system) would
contain 13,824 C64 chips, consisting of 1,105,920 processors capable of running 2,211,840
concurrent threads.

[edit]Software

Cyclops64 exposes much of the underyling hardware to the programmer, allowing the programmer to
write very high performance, finely tuned software. One negative consequence is that efficiently
programming Cyclops64 is difficult.[citation needed]

The system is expected to support TiNy-Threads (a threading library developed at the University of

Delaware) and POSIX Threads.

[edit]Design and fabrication

Verification testing and system software development is being done at the University of Delaware.
OSIX Threads, or Pthreads, is a POSIX standard for threads. The standard, POSIX.1c, Threads
extensions (IEEE Std 1003.1c-1995), defines an API for creating and manipulating threads.

Implementations of the API are available on many Unix-like POSIX systems such

as FreeBSD, NetBSD, GNU/Linux, Mac OS X and Solaris, but Microsoft Windows implementations
also exist. For example, the pthreads-w32 is available and supports a subset of the Pthread API for
the Windows 32-bit platform.[1]

Pthreads defines a set of C programming language types, functions and constants. It is implemented

with a pthread.h header and a thread library.

There are around 100 Pthreads procedures, all prefixed "pthread_" and they can be categorized into
four groups:

 Thread management - creating, joining threads etc

 Mutexes
 Condition variables
 Synchronize between threads using read/write locks and barriers

The POSIX semaphore API works with POSIX threads but is not part of threads standard, having
been defined in the POSIX.1b, Real-time extensions (IEEE Std 1003.1b-1993) standard.
Consequently the semaphore procedures are prefixed by "sem_" instead of "pthread_".

[edit]Example

An example illustrating the use of Pthreads in C:

#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>

#define NUM_THREADS 5

void *TaskCode(void *argument)

{
int tid;

tid = *((int *) argument);

printf("Hello World! It's me, thread %d!\n", tid);

/* optionally: insert more useful stuff here */

return NULL;
}

int main (int argc, char *argv[])

{
pthread_t threads[NUM_THREADS];
int thread_args[NUM_THREADS];
int rc, i;

/* create all threads */

for (i=0; i<NUM_THREADS; i++) {
thread_args[i] = i;
printf("In main: creating thread %d\n", i);
rc = pthread_create(&threads[i], NULL, TaskCode, (void *)
&thread_args[i]);
assert(0 == rc);
}

/* wait for all threads to complete */

for (i=0; i<NUM_THREADS; i++) {
rc = pthread_join(threads[i], NULL);
assert(0 == rc);
}

exit(EXIT_SUCCESS);
}

This program creates five threads, each executing the function TaskCode that prints the unique
number of this thread to standard output.

[edit]Pthreads-w32: Open Source POSIX Threads for Win32

Windows is not supporting the pthreads standard natively, therefore the Pthreads-w32 projects seeks
to provide a portable and open-source implementation. It can be also used to port Unix software
(which use pthreads) with little or no modification to the windows platform [2]. With some additional
patches the last version 2.8.0 is compatible with 64bit Windows systems. [3][4]

[edit]See also