Products : Goose : Domain-Specific Compiler

Domain-Specific Compiler


  #pragma goose parallel for loopcounter(i, j) \
                             precision("double") 
    for (i = 0; i < n; i++) {
        for (j = 0; j < n; j++) {
            for (k = 0; k < 3; k++) {
                dx[k] = x[j][k] - x[i][k];
            }
            r2 = dx[0] * dx[0] + dx[1] * dx[1] +
                 dx[2] * dx[2] + eps2;
            rinv = rsqrt(r2);
            mrinv = m[j] * rinv;
            mr3inv = mrinv * rinv * rinv;
            for (k = 0; k < 3; k++) {
                a[i][k] += mr3inv * dx[k];
            }
            pot[i] -= mrinv;      
        }
    }

Key Features


Supported Languages & Accelerators

As a programming language, Goose supports C. As hardware accelerators, it supports our GRAPE-DR and GPUs of both AMD & NVIDIA. The following languages and hardware accelerators will be supported soon.

Contents of the Package:

Required Environment

Runs on 64-bit Linux (x86_64). Functions for GRAPE-DR are not fully tested on 32-bit environment yet, although functions for other accelerators should work on it.

Goose internally uses the following softwares. They need to be installed beforehand.

Required Softwares:
Accelerator
GRAPE-DRAMDNVIDIA
ruby ***
gcc ***
ATI Stream SDK *
CUDA *
grapepkg *
LSUMP **
VSM *

License

Permission for use of the Goose Software Package (hereafter the "Software") is granted only to owners of a copy of the Software. The Software may not be redistributed.

The copyright of the software belongs to K&F Computing Research. Co.

Products Line up

Sample Programs

The followings are examples of application programs which can be compiled with the Goose C Compiler.

Measured Performance


gravitational interactions (double precision)
ni nj GRAPE-DR AMD NVIDIA CPU
1core		 CPU
8cores
1k 1k 0.79 (30.1) 0.40 (15.4) 1.05 (39.9) 0.07 (2.5) 0.45 (17.0)
1k 8k 1.13 (42.8) 0.73 (27.8) 1.49 (56.5) 0.07 (2.5) 0.45 (17.1)
1k 64k 1.18 (44.9) 0.81 (30.8) 1.55 (58.8) 0.07 (2.5) 0.45 (17.1)
8k 8k 1.63 (62.0) 2.65 (100.7) 1.63 (62.0) 0.07 (2.5) 0.46 (17.5)
64k 64k 1.88 (71.4) 3.44 (130.6) 1.66 (62.9) 0.06 (2.2) 0.46 (17.5)

gravitational interactions
(double precision for addition & subtraction,
single precision for other operations)
ni nj GRAPE-DR* AMD NVIDIA
1k 1k 0.85 (32.2) - 3.28 (124.5) - -
1k 8k 1.24 (47.1) - 5.54 (210.4) - -
1k 64k 1.31 (49.9) - 6.15 (233.8) - -
8k 8k 1.88 (71.6) - 7.81 (296.8) - -
64k 64k 2.22 (84.5) - 8.40 (319.2) - -

gravitational interactions (single precision)
ni nj AMD NVIDIA
1k 1k - 0.56 (21.5) 5.39 (204.9) - -
1k 8k - 1.50 (57.1) 10.82 (411.3) - -
1k 64k - 1.87 (71.1) 12.16 (461.9) - -
8k 8k - 10.15 (385.8) 16.33 (620.6) - -
64k 64k - 19.78 (753.1) 18.17 (690.6) - -

Measured Accuracy

Examples of Intermediate Descriptions

C-language description passed on to Goose: 

  #pragma goose parallel for loopcounter(i, j) \
                             precision("double") 
    for (i = 0; i < n; i++) {
        for (j = 0; j < n; j++) {
            for (k = 0; k < 3; k++) {
                dx[k] = x[j][k] - x[i][k];
            }
            r2 = dx[0] * dx[0] + dx[1] * dx[1] +
                 dx[2] * dx[2] + eps2;
            rinv = rsqrt(r2);
            mrinv = m[j] * rinv;
            mr3inv = mrinv * rinv * rinv;
            for (k = 0; k < 3; k++) {
                a[i][k] += mr3inv * dx[k];
            }
            pot[i] -= mrinv;      
        }
    }
Description generated by Goose

For GRAPE-DR:
   Kernel & API calls (in C language)
   The kernel (in VSM language) 
    loop body
    vlen 4
    bm ccc_reg0 $t
    upassa $ti $lr0v $lm120v
     ....
    fadd $lr16v $lm104v $t 
    upassa $ti $ti $lm104v
    nop
    nop
    fadd $lr24v $lm112v $t 
    upassa $ti $ti $lm112v
    nop
    nop

For GPU (AMD)
   Kernel & API calls (in C language)
   The kernel (in ATI-IL language) 
    whileloop
      sample_resource(7)_sampler(7) r300, r200.xy
      sample_resource(8)_sampler(8) r301, r200.xy
      sample_resource(9)_sampler(9) r302, r200.xy
      ....
    ;; force
    func 0
      ixor r999, r100, l8
      dadd r747.xy, r300.xy, r999.xy
      dadd r747.zw, r300.zw, r999.zw
      ixor r999, r101, l8
      ....

For GPU (NVIDIA)
   Kernel & API calls (in CUDA C language)
   The kernel (in CUDA C language) 
    extern __shared__ char smembuf_[];
    int kbdim_ = blockDim.x;
    f00_jp_t *f00_jp_smem_ = (f00_jp_t *) smembuf_;
    ....
    for (int j_ = jstart_; j_ < jsup_; j_ += jstride_) {
        dx_0_ = f00_jp_smem_[j_].x_j_0_ - f00_ip_[isrc_].x_i_0_;
        dx_1_ = f00_jp_smem_[j_].x_j_1_ - f00_ip_[isrc_].x_i_1_;
        dx_2_ = f00_jp_smem_[j_].x_j_2_ - f00_ip_[isrc_].x_i_2_;
        r2 = dx_0_ * dx_0_ + dx_1_ * dx_1_ + dx_2_ * dx_2_ + eps2;
        rinv = rsqrt(r2);
        ....

Old Products

Goose Personal Edition (International Price: 420,000 JPY)

A product for up to 10 users. There is no limitation for the number of local copies installed into different PCs.

Goose Institutional Edition (International Price: 997,500 JPY)

A product for more than 10 users. There is no limitation for the number of local copies installed into different PCs. There is no limitation for the number of users as long as the user belongs to the user group.

Even if a user belongs to a group that consists of more than 10 members (e.g. a university, an enterprise), the user can purchase the personal edition, as long as the number of actual users does not exceed 10.

All product includes one-year free version up service, and one-year technical support. Please contact info@kfcr.jp for purchase. We accept the following payment methods : PayPal, IPMO, and Wire Transfer.

Related Information