Changeset 7170


Ignore:
Timestamp:
11/08/10 10:50:58 (9 years ago)
Author:
rlentz
Message:

Demo using EJB components on Glassfish, supporting multi-language integration within ImageJ. Feature integration examples include OpenCL integration with Java using JOCL.

Location:
branches/maven/projects/opencl-decon
Files:
18 added
6 edited

Legend:

Unmodified
Added
Removed
  • branches/maven/projects/opencl-decon

    • Property svn:ignore set to
      build
  • branches/maven/projects/opencl-decon/nbproject/build-impl.xml

    r7094 r7170  
    4343        <property file="nbproject/private/private.properties"/> 
    4444    </target> 
    45     <target depends="-pre-init,-init-private" name="-init-user"> 
     45    <target name="-pre-init-libraries"> 
     46        <property location="lib/JOCL-0.1.4-beta1-bin-apple-x86_64/nblibraries.properties" name="libraries.path"/> 
     47        <dirname file="${libraries.path}" property="libraries.dir.nativedirsep"/> 
     48        <pathconvert dirsep="/" property="libraries.dir"> 
     49            <path path="${libraries.dir.nativedirsep}"/> 
     50        </pathconvert> 
     51        <basename file="${libraries.path}" property="libraries.basename" suffix=".properties"/> 
     52        <available file="${libraries.dir}/${libraries.basename}-private.properties" property="private.properties.available"/> 
     53    </target> 
     54    <target depends="-pre-init-libraries" if="private.properties.available" name="-init-private-libraries"> 
     55        <loadproperties encoding="ISO-8859-1" srcfile="${libraries.dir}/${libraries.basename}-private.properties"> 
     56            <filterchain> 
     57                <replacestring from="$${base}" to="${libraries.dir}"/> 
     58                <escapeunicode/> 
     59            </filterchain> 
     60        </loadproperties> 
     61    </target> 
     62    <target depends="-pre-init,-init-private,-init-private-libraries" name="-init-libraries"> 
     63        <loadproperties encoding="ISO-8859-1" srcfile="${libraries.path}"> 
     64            <filterchain> 
     65                <replacestring from="$${base}" to="${libraries.dir}"/> 
     66                <escapeunicode/> 
     67            </filterchain> 
     68        </loadproperties> 
     69    </target> 
     70    <target depends="-pre-init,-init-private,-init-libraries" name="-init-user"> 
    4671        <property file="${user.properties.file}"/> 
    4772        <!-- The two properties below are usually overridden --> 
     
    5075        <property name="default.javac.target" value="1.4"/> 
    5176    </target> 
    52     <target depends="-pre-init,-init-private,-init-user" name="-init-project"> 
     77    <target depends="-pre-init,-init-private,-init-libraries,-init-user" name="-init-project"> 
    5378        <property file="nbproject/configs/${config}.properties"/> 
    5479        <property file="nbproject/project.properties"/> 
    5580    </target> 
    56     <target depends="-pre-init,-init-private,-init-user,-init-project,-init-macrodef-property" name="-do-init"> 
     81    <target depends="-pre-init,-init-private,-init-libraries,-init-user,-init-project,-init-macrodef-property" name="-do-init"> 
    5782        <available file="${manifest.file}" property="manifest.available"/> 
    5883        <available file="${application.splash}" property="splashscreen.available"/> 
     
    182207        <!-- You can override this target in the ../build.xml file. --> 
    183208    </target> 
    184     <target depends="-pre-init,-init-private,-init-user,-init-project,-do-init" name="-init-check"> 
     209    <target depends="-pre-init,-init-private,-init-libraries,-init-user,-init-project,-do-init" name="-init-check"> 
    185210        <fail unless="src.dir">Must set src.dir</fail> 
    186211        <fail unless="test.src.dir">Must set test.src.dir</fail> 
     
    481506        <property name="ap.cmd.line.internal" value=""/> 
    482507    </target> 
    483     <target depends="-pre-init,-init-private,-init-user,-init-project,-do-init,-post-init,-init-check,-init-macrodef-property,-init-macrodef-javac,-init-macrodef-junit,-init-macrodef-nbjpda,-init-macrodef-debug,-init-macrodef-java,-init-presetdef-jar,-init-ap-cmdline" name="init"/> 
     508    <target depends="-pre-init,-init-private,-init-libraries,-init-user,-init-project,-do-init,-post-init,-init-check,-init-macrodef-property,-init-macrodef-javac,-init-macrodef-junit,-init-macrodef-nbjpda,-init-macrodef-debug,-init-macrodef-java,-init-presetdef-jar,-init-ap-cmdline" name="init"/> 
    484509    <!-- 
    485510                =================== 
  • branches/maven/projects/opencl-decon/nbproject/genfiles.properties

    r7094 r7170  
    1 build.xml.data.CRC32=64a48c97 
     1build.xml.data.CRC32=d06dc660 
    22build.xml.script.CRC32=4adf5fd2 
    33build.xml.stylesheet.CRC32=28e38971@1.38.2.45 
    44# This file is used by a NetBeans-based IDE to track changes in generated files such as build-impl.xml. 
    55# Do not edit this file. You may delete it but then the IDE will never regenerate such files for you. 
    6 nbproject/build-impl.xml.data.CRC32=64a48c97 
    7 nbproject/build-impl.xml.script.CRC32=0f5ba22a 
     6nbproject/build-impl.xml.data.CRC32=d06dc660 
     7nbproject/build-impl.xml.script.CRC32=2a662246 
    88nbproject/build-impl.xml.stylesheet.CRC32=f33e10ff@1.38.2.45 
  • branches/maven/projects/opencl-decon/nbproject/project.properties

    r7094 r7170  
    2727endorsed.classpath= 
    2828excludes= 
     29file.reference.hessian-4.0.7.jar=lib/JOCL-0.1.4-beta1-bin-apple-x86_64/hessian-4.0.7.jar 
    2930file.reference.ij.jar=lib/ij.jar 
    30 file.reference.jocl.jar=lib/jocl.jar 
    31 file.reference.opencl-decon-lib=lib/ 
     31file.reference.JOCL-0.1.4-beta1.jar=lib/JOCL-0.1.4-beta1-bin-apple-x86_64/JOCL-0.1.4-beta1-bin-apple-x86_64/JOCL-0.1.4-beta1.jar 
    3232file.reference.opencl-decon-src=src 
    3333file.reference.opencl-decon-test=test 
     
    3535jar.compress=false 
    3636javac.classpath=\ 
    37     ${file.reference.opencl-decon-lib}:\ 
    38     ${file.reference.jocl.jar}:\ 
    39     ${file.reference.ij.jar} 
     37    ${file.reference.ij.jar}:\ 
     38    ${libs.JOCL.classpath}:\ 
     39    ${libs.GlueGen.classpath}:\ 
     40    ${file.reference.hessian-4.0.7.jar} 
    4041# Space-separated list of extra javac options 
    4142javac.compilerargs= 
     
    6364javadoc.version=false 
    6465javadoc.windowtitle= 
    65 main.class= 
     66main.class=fasthartleytransform.FastHartleyTransform 
    6667manifest.file=manifest.mf 
    6768meta.inf.dir=${src.dir}/META-INF 
     
    6970run.classpath=\ 
    7071    ${javac.classpath}:\ 
    71     ${build.classes.dir} 
     72    ${build.classes.dir}:\ 
     73    ${libs.junit_4.classpath}:\ 
     74    ${file.reference.JOCL-0.1.4-beta1.jar} 
    7275# Space-separated list of JVM arguments used when running the project 
    7376# (you may also define separate properties like run-sys-prop.name=value instead of -Dname=value 
    7477# or test-sys-prop.name=value to set system properties for unit tests): 
    75 run.jvmargs= 
     78run.jvmargs=-Djava.library.path="${workspace_loc:project}/lib/JOCL-0.1.4-beta1-bin-apple-x86_64/JOCL-0.1.4-beta1-bin-apple-x86_64 ;${env_var:PATH}" 
    7679run.test.classpath=\ 
    7780    ${javac.test.classpath}:\ 
  • branches/maven/projects/opencl-decon/nbproject/project.xml

    r7094 r7170  
    1212            </test-roots> 
    1313        </data> 
     14        <libraries xmlns="http://www.netbeans.org/ns/ant-project-libraries/1"> 
     15            <definitions>lib/JOCL-0.1.4-beta1-bin-apple-x86_64/nblibraries.properties</definitions> 
     16        </libraries> 
     17        <references xmlns="http://www.netbeans.org/ns/ant-project-references/1"/> 
    1418    </configuration> 
    1519</project> 
  • branches/maven/projects/opencl-decon/src/publication/FHT3DExample.java

    r6961 r7170  
    11package publication; 
    2  
    32 
    43import java.io.IOException; 
     
    1817import com.jogamp.opencl.CLMemory.Mem; 
    1918 
    20 public class FHT3DExample 
    21 { 
    22         private static boolean DEBUG = false; 
    23         private static boolean PROFILINGMSG = false; 
    24         private CLContext context; 
    25         private CLBuffer<FloatBuffer> clFloatBufferDATA; 
    26         private CLBuffer<FloatBuffer> clFloatBufferS; 
    27         private CLBuffer<FloatBuffer> clFloatBufferC; 
    28         private CLBuffer<FloatBuffer> clFloatBufferSW; 
    29         private CLBuffer<FloatBuffer> clFloatBufferCW; 
    30         private CLBuffer<FloatBuffer> clFloatBufferSH; 
    31         private CLBuffer<FloatBuffer> clFloatBufferCH; 
    32  
    33         private CLProgram programFHT3D; 
    34         private CLKernel kernelsw; 
    35         private CLKernel kernelsh; 
    36         private CLKernel kernels; 
    37         private CLKernel kernelf; 
    38         private CLCommandQueue queue; 
    39         private int globalWorkSize = 1; 
    40         private int localWorkSize = 1; 
    41         private int maxComputeUnits = 0; 
    42         private FloatBuffer dataA; 
    43         private int w = 0; 
    44         private int h = 0; 
    45         private int d = 0; 
    46         private int inverse = 0; 
    47         /* 
    48          * Constructor used for OpenCL persistence, sets up GPU context and allocates arrays based on size of recent calls 
    49          * 
    50          * it takes in the properties of the inputs but does not calculate the results. 
    51          * 
    52          */ 
    53         protected void release() 
    54         { 
    55                 dataA = null; 
    56                 queue.release(); 
    57         } 
    58  
    59         //protected void finalize() throws Throwable 
    60         //{ 
    61         //      dataA = null; 
    62         //      queue.release(); 
    63         //} 
    64          
    65          public static boolean powerOf2Size(int w) { 
    66                 {int i=2; while(i<w) {i = i * 2;} return i==w;} 
    67             } 
    68           
    69         public FHT3DExample ( int w, int h, int d ) 
    70         { 
    71                 if( DEBUG )  System.out.println( "Asserting that dimensions meet design criteria"); 
    72                 assert (w == h); 
    73                 assert (h == d); 
    74                 assert (powerOf2Size(d)); 
    75                 assert (d <= 1024); 
    76                  
    77                 this.w = w;  
    78                 this.h = h; 
    79                 this.d = d; 
    80  
    81                 try { 
    82  
    83                         if( DEBUG )  System.out.println( "Local work size dimensions are max array size of"); 
    84                         CLPlatform[] platforms = CLPlatform.listCLPlatforms(); 
    85                         if( DEBUG ) for(CLPlatform clPlatform : platforms) 
    86                                 System.out.println("Discovered " + clPlatform.getName() ); 
    87                         context = CLContext.create( Type.GPU ); 
    88  
    89                         this.programFHT3D = context.createProgram( FHT3DExample.class.getResourceAsStream("fht.cl") ).build(); 
    90                 } 
    91                 catch (IOException e) 
    92                 { 
    93                         e.printStackTrace(); 
    94                 } 
    95  
    96                 if( DEBUG )  System.out.println( "assign the kernel" ); 
    97                 this.kernelsw = programFHT3D.createCLKernel("fhtsw"); 
    98                 this.kernelsh = programFHT3D.createCLKernel("fhtsh"); 
    99                 this.kernels = programFHT3D.createCLKernel("fhts"); 
    100                 this.kernelf = programFHT3D.createCLKernel("fhtf"); 
    101  
    102                 if( DEBUG )  System.out.println( "get a command queue" ); 
    103                 this.queue = context.getMaxFlopsDevice().createCommandQueue( CLCommandQueue.Mode.PROFILING_MODE ); 
    104  
    105                 if( DEBUG )  System.out.println( "find the max compute unites"); 
    106                 maxComputeUnits = queue.getDevice().getMaxComputeUnits(); 
    107  
    108                 this.dataA = ByteBuffer.allocateDirect(d*w*h*4).order(ByteOrder.nativeOrder()).asFloatBuffer(); 
    109                 FloatBuffer sw = ByteBuffer.allocateDirect(w).order(ByteOrder.nativeOrder()).asFloatBuffer(); 
    110                 FloatBuffer cw = ByteBuffer.allocateDirect(w).order(ByteOrder.nativeOrder()).asFloatBuffer(); 
    111                 FloatBuffer sh = ByteBuffer.allocateDirect(h).order(ByteOrder.nativeOrder()).asFloatBuffer(); 
    112                 FloatBuffer ch = ByteBuffer.allocateDirect(h).order(ByteOrder.nativeOrder()).asFloatBuffer(); 
    113                 FloatBuffer s = ByteBuffer.allocateDirect(d).order(ByteOrder.nativeOrder()).asFloatBuffer(); 
    114                 FloatBuffer c = ByteBuffer.allocateDirect(d).order(ByteOrder.nativeOrder()).asFloatBuffer(); 
    115  
    116                 if( DEBUG )  System.out.println( "Generating sin cos tables"); 
    117                 makeSinCosTables(d,s,c); 
    118                 makeSinCosTables(w,sw,cw); 
    119                 makeSinCosTables(h,sh,ch); 
    120  
    121                 if( DEBUG )  System.out.println( "Create a CLMemory Structure for  c, w, ..."); 
    122                 clFloatBufferC = context.createBuffer( c, Mem.READ_ONLY ); 
    123                 clFloatBufferS = context.createBuffer( s, Mem.READ_ONLY  );            
    124                 clFloatBufferCW = context.createBuffer( cw, Mem.READ_ONLY ); 
    125                 clFloatBufferSW = context.createBuffer( sw, Mem.READ_ONLY  );            
    126                 clFloatBufferCH = context.createBuffer( ch, Mem.READ_ONLY ); 
    127                 clFloatBufferSH = context.createBuffer( sh, Mem.READ_ONLY  ); 
    128                 clFloatBufferDATA = context.createFloatBuffer( d*w*h, Mem.READ_WRITE ); 
    129  
    130                 if( DEBUG )  System.out.println( "Making kernel assignments"); 
    131                 kernels.setArg( 0, clFloatBufferDATA ); 
    132                 kernelsw.setArg( 0, clFloatBufferDATA ); 
    133                 kernelsh.setArg( 0, clFloatBufferDATA ); 
    134                 kernelf.setArg( 0, clFloatBufferDATA ); 
    135                 kernels.setArg( 1, clFloatBufferS ); 
    136                 kernels.setArg( 2, clFloatBufferC ); 
    137                 kernelsw.setArg( 1, clFloatBufferSW ); 
    138                 kernelsw.setArg( 2, clFloatBufferCW ); 
    139                 kernelsh.setArg( 1, clFloatBufferSH ); 
    140                 kernelsh.setArg( 2, clFloatBufferCH ); 
    141                 kernelsw.setArg( 3, w ); 
    142                 kernelsw.setArg( 4, h ); 
    143                 kernelsw.setArg( 5, d ); 
    144                 kernels.setArg( 3, w ); 
    145                 kernels.setArg( 4, h ); 
    146                 kernels.setArg( 5, d ); 
    147                 kernelsh.setArg( 3, w ); 
    148                 kernelsh.setArg( 4, h ); 
    149                 kernelsh.setArg( 5, d ); 
    150                 kernelf.setArg( 1, w ); 
    151                 kernelf.setArg( 2, h ); 
    152                 kernelf.setArg( 3, d ); 
    153                 kernels.setArg( 6, maxComputeUnits ); 
    154                 kernelsw.setArg( 6, maxComputeUnits ); 
    155                 kernelsh.setArg( 6, maxComputeUnits ); 
    156                 kernelf.setArg( 4, maxComputeUnits ); 
    157  
    158                 kernelsh.setNullArg( 7, h*4 ); 
    159                 kernelsh.setNullArg( 8, h ); 
    160                 kernelsh.setNullArg( 9, h ); 
    161                 kernelsw.setNullArg( 7, w*4 ); 
    162                 kernelsw.setNullArg( 8, w ); 
    163                 kernelsw.setNullArg( 9, w ); 
    164                 kernels.setNullArg( 7, d*4 ); 
    165                 kernels.setNullArg( 8, d ); 
    166                 kernels.setNullArg( 9, d ); 
    167  
    168                 if( DEBUG )  System.out.println( "Copying data to the device"); 
    169                 queue.putWriteBuffer( clFloatBufferC, false ); 
    170                 queue.putWriteBuffer( clFloatBufferS, false ); 
    171                 queue.putWriteBuffer( clFloatBufferCW, false ); 
    172                 queue.putWriteBuffer( clFloatBufferSW, false ); 
    173                 queue.putWriteBuffer( clFloatBufferCH, false ); 
    174                 queue.putWriteBuffer( clFloatBufferSH, false ); 
    175  
    176         } 
    177  
    178         public synchronized long  run(float[][] data, boolean inverse) 
    179         { 
    180  
    181                         if( DEBUG )  System.out.println( "add the input data to the objects buffer "); 
    182                         for(int i = 0; i < d; i++) 
    183                                 for(int j = 0; j < w*h; j++) 
    184                                         dataA.put(i*w*h + j, data[i][j] ); 
    185  
    186                         long executionTime = run(dataA, inverse); 
    187  
    188  
    189                         if( DEBUG )  System.out.println("Copy data to the float[][]..."); 
    190                         for(int i = 0; i < d; i++) 
    191                                 for(int j = 0; j < w*h; j++) 
    192                                         data[i][j] = dataA.get( i*w*h + j ); 
    193                          
    194                         return executionTime; 
    195          
    196         } 
    197  
    198         public synchronized long run(FloatBuffer data, boolean inverse) 
    199         { 
    200                 clFloatBufferDATA.use(data); 
    201                  
    202                 if( DEBUG ) System.out.println("translate for inverse"); 
    203                 this.inverse = (inverse == true) ? 1 : 0; 
    204  
    205                 if( DEBUG )  System.out.println("Setting CLBuffer to input data buffer..."); 
    206                 queue.putWriteBuffer( clFloatBufferDATA, false ); 
    207  
    208                 long executionTime = run(); 
    209  
    210                 if( DEBUG )  System.out.println("Reading back data from the device..."); 
    211                 queue.putReadBuffer( clFloatBufferDATA, true ); 
    212                  
    213                 return executionTime; 
    214         } 
    215  
    216  
    217         private synchronized long run()  
    218         { 
    219  
    220                  
    221                 //this changes every time 
    222                 kernelf.setArg( 5, inverse ); 
    223  
    224                 if( DEBUG ) { System.out.println("Setting global max and mins...");} 
    225                 globalWorkSize = w*maxComputeUnits; 
    226                 localWorkSize = w; 
    227  
    228                 if( DEBUG ) { System.out.println("Writing the input data set to the device...");} 
    229                 //put the data on the card 
    230                 queue.putWriteBuffer( clFloatBufferDATA, false ); 
    231  
    232                 long executionTime = System.currentTimeMillis(); 
    233                  
    234                 if( DEBUG ) { System.out.println("Enqueing the kernel w...");} 
    235                 queue.put1DRangeKernel( kernelsw, 0, globalWorkSize, localWorkSize ); 
    236  
    237                 //if( DEBUG ) { System.out.println("Setting global max and mins...");} 
    238                 //globalWorkSize = h*maxComputeUnits; 
    239                 //localWorkSize = h; 
    240  
    241                 if( DEBUG ) { System.out.println("Enqueing the kernel h...");} 
    242                 queue.put1DRangeKernel( kernelsh, 0, globalWorkSize, localWorkSize ); 
    243  
    244                 //if( DEBUG ) { System.out.println("Setting global max and mins...");} 
    245                 //globalWorkSize = d*maxComputeUnits; 
    246                 //localWorkSize = d; 
    247  
    248                 if( DEBUG ) { System.out.println("Enqueing the kernel s...");} 
    249                 queue.put1DRangeKernel( kernels, 0, globalWorkSize, localWorkSize ); 
    250  
    251                 if( DEBUG ) { System.out.println("Enqueing the kernel f...");} 
    252                 queue.put1DRangeKernel( kernelf, 0, globalWorkSize, localWorkSize ); 
    253  
    254                 if( DEBUG ) { System.out.println("Waiting for CLFinish to return...");} 
    255                 queue.finish(); 
    256                  
    257                 executionTime = System.currentTimeMillis() - executionTime; 
    258                  
    259                 return executionTime; 
    260         } 
    261  
    262         public double getExecutionTimeInNS(CLEvent clevent) 
    263         { 
    264                 long start; 
    265                 long end; 
    266  
    267                 end = clevent.getProfilingInfo( ProfilingCommand.END ); 
    268                 start = clevent.getProfilingInfo( ProfilingCommand.START ); 
    269  
    270                 // convert nanoseconds to seconds on return 
    271                 return (double)1.0e-9 * (end - start); 
    272         } 
    273  
    274         public static void main(String[] args) 
    275         { 
    276                 long time = 0; //used to track duration of ex 
    277                 String path = "/home/loci/NetBeansProjects/i3d/"; 
    278                 int d = 512; 
    279                 int h = 512; 
    280                 int w = 512; 
    281  
    282                 if( DEBUG ) { System.out.println("Creating NIO Backed Arrays...");} 
    283                 FloatBuffer dataA = ByteBuffer.allocateDirect(d*w*h*4).order(ByteOrder.nativeOrder()).asFloatBuffer(); 
    284  
    285                 if( DEBUG ) { System.out.println("Adding good data to the arrays..."); } 
    286                 HelperUtils.injectGoodData( dataA, path, "dataAswapQuadrants_float_512_262144"); 
    287  
    288                 if( DEBUG ) { System.out.println("Starting opencl setup..."); } 
    289                 time = System.currentTimeMillis(); 
    290                 FHT3DExample f = new FHT3DExample(  w,  h,  d ); 
    291                 time = System.currentTimeMillis() - time; 
    292                 if(PROFILINGMSG) System.out.println("OpenCL setup took " + (time) + " ms."); 
    293  
    294                 if( DEBUG ) { System.out.println("Starting opencl setup..."); } 
    295                 time = System.currentTimeMillis(); 
    296                 f.run(dataA, false); 
    297                 time = System.currentTimeMillis() - time; 
    298                 if(PROFILINGMSG) System.out.println("OpenCL execution took " + (time) + " ms."); 
    299  
    300  
    301                 //HelperUtils.compareResults( path, dataA, "dataAswapQuadrants_float_512_262144"); 
    302                 HelperUtils.compareResults( path, dataA, "dataAfht1_float_512_262144"); 
    303                 // HelperUtils.compareResults(dataACopy, dataA, 10, "debugging"); 
    304  
    305         } 
    306          
    307         public static void makeSinCosTables( int maxN, FloatBuffer s, FloatBuffer c ) { 
    308                 int n = maxN/4; 
    309                 double theta = 0.0; 
    310                 double dTheta = 2.0 * Math.PI/maxN; 
    311                 for (int i=0; i<n; i++)  
    312                 { 
    313                         c.put( i, (float)Math.cos(theta) ); 
    314                         s.put( i, (float)Math.sin(theta) ); 
    315                         theta += dTheta; 
    316                 } 
    317         } 
     19public class FHT3DExample { 
     20 
     21    private static boolean DEBUG = false; 
     22    private static boolean PROFILINGMSG = false; 
     23 
     24    private CLContext context; 
     25    private CLBuffer<FloatBuffer> clFloatBufferDATA; 
     26    private CLBuffer<FloatBuffer> clFloatBufferS; 
     27    private CLBuffer<FloatBuffer> clFloatBufferC; 
     28    private CLBuffer<FloatBuffer> clFloatBufferSW; 
     29    private CLBuffer<FloatBuffer> clFloatBufferCW; 
     30    private CLBuffer<FloatBuffer> clFloatBufferSH; 
     31    private CLBuffer<FloatBuffer> clFloatBufferCH; 
     32    private CLProgram programFHT3D; 
     33    private CLKernel kernelsw; 
     34    private CLKernel kernelsh; 
     35    private CLKernel kernels; 
     36    private CLKernel kernelf; 
     37    private CLCommandQueue queue; 
     38    private int globalWorkSize = 1; 
     39    private int localWorkSize = 1; 
     40    private int maxComputeUnits = 0; 
     41    private FloatBuffer dataA; 
     42    private int w = 0; 
     43    private int h = 0; 
     44    private int d = 0; 
     45    private int inverse = 0; 
     46    /* 
     47     * Constructor used for OpenCL persistence, sets up GPU context and allocates arrays based on size of recent calls 
     48     * 
     49     * it takes in the properties of the inputs but does not calculate the results. 
     50     * 
     51     */ 
     52 
     53    protected void release() { 
     54        dataA = null; 
     55        queue.release(); 
     56    } 
     57 
     58    //protected void finalize() throws Throwable 
     59    //{ 
     60    //  dataA = null; 
     61    //  queue.release(); 
     62    //} 
     63    public static boolean powerOf2Size(int w) { 
     64        { 
     65            int i = 2; 
     66            while (i < w) { 
     67                i = i * 2; 
     68            } 
     69            return i == w; 
     70        } 
     71    } 
     72 
     73    public FHT3DExample(int w, int h, int d) { 
     74        if (DEBUG) { 
     75            System.out.println("Asserting that dimensions meet design criteria"); 
     76        } 
     77        assert (w == h); 
     78        assert (h == d); 
     79        assert (powerOf2Size(d)); 
     80        assert (d <= 1024); 
     81 
     82        this.w = w; 
     83        this.h = h; 
     84        this.d = d; 
     85 
     86        try { 
     87 
     88            if (DEBUG) { 
     89                System.out.println("Local work size dimensions are max array size of"); 
     90            } 
     91            CLPlatform[] platforms = CLPlatform.listCLPlatforms(); 
     92            if (DEBUG) { 
     93                for (CLPlatform clPlatform : platforms) { 
     94                    System.out.println("Discovered " + clPlatform.getName()); 
     95                } 
     96            } 
     97            context = CLContext.create(Type.GPU); 
     98 
     99            this.programFHT3D = context.createProgram(FHT3DExample.class.getResourceAsStream("fht.cl")).build(); 
     100        } catch (IOException e) { 
     101            e.printStackTrace(); 
     102        } 
     103 
     104        if (DEBUG) { 
     105            System.out.println("assign the kernel"); 
     106        } 
     107        this.kernelsw = programFHT3D.createCLKernel("fhtsw"); 
     108        this.kernelsh = programFHT3D.createCLKernel("fhtsh"); 
     109        this.kernels = programFHT3D.createCLKernel("fhts"); 
     110        this.kernelf = programFHT3D.createCLKernel("fhtf"); 
     111 
     112        if (DEBUG) { 
     113            System.out.println("get a command queue"); 
     114        } 
     115        this.queue = context.getMaxFlopsDevice().createCommandQueue(CLCommandQueue.Mode.PROFILING_MODE); 
     116 
     117        if (DEBUG) { 
     118            System.out.println("find the max compute unites"); 
     119        } 
     120        maxComputeUnits = queue.getDevice().getMaxComputeUnits(); 
     121 
     122        this.dataA = ByteBuffer.allocateDirect(d * w * h * 4).order(ByteOrder.nativeOrder()).asFloatBuffer(); 
     123        FloatBuffer sw = ByteBuffer.allocateDirect(w).order(ByteOrder.nativeOrder()).asFloatBuffer(); 
     124        FloatBuffer cw = ByteBuffer.allocateDirect(w).order(ByteOrder.nativeOrder()).asFloatBuffer(); 
     125        FloatBuffer sh = ByteBuffer.allocateDirect(h).order(ByteOrder.nativeOrder()).asFloatBuffer(); 
     126        FloatBuffer ch = ByteBuffer.allocateDirect(h).order(ByteOrder.nativeOrder()).asFloatBuffer(); 
     127        FloatBuffer s = ByteBuffer.allocateDirect(d).order(ByteOrder.nativeOrder()).asFloatBuffer(); 
     128        FloatBuffer c = ByteBuffer.allocateDirect(d).order(ByteOrder.nativeOrder()).asFloatBuffer(); 
     129 
     130        if (DEBUG) { 
     131            System.out.println("Generating sin cos tables"); 
     132        } 
     133        makeSinCosTables(d, s, c); 
     134        makeSinCosTables(w, sw, cw); 
     135        makeSinCosTables(h, sh, ch); 
     136 
     137        if (DEBUG) { 
     138            System.out.println("Create a CLMemory Structure for  c, w, ..."); 
     139        } 
     140        clFloatBufferC = context.createBuffer(c, Mem.READ_ONLY); 
     141        clFloatBufferS = context.createBuffer(s, Mem.READ_ONLY); 
     142        clFloatBufferCW = context.createBuffer(cw, Mem.READ_ONLY); 
     143        clFloatBufferSW = context.createBuffer(sw, Mem.READ_ONLY); 
     144        clFloatBufferCH = context.createBuffer(ch, Mem.READ_ONLY); 
     145        clFloatBufferSH = context.createBuffer(sh, Mem.READ_ONLY); 
     146        clFloatBufferDATA = context.createFloatBuffer(d * w * h, Mem.READ_WRITE); 
     147 
     148        if (DEBUG) { 
     149            System.out.println("Making kernel assignments"); 
     150        } 
     151        kernels.setArg(0, clFloatBufferDATA); 
     152        kernelsw.setArg(0, clFloatBufferDATA); 
     153        kernelsh.setArg(0, clFloatBufferDATA); 
     154        kernelf.setArg(0, clFloatBufferDATA); 
     155        kernels.setArg(1, clFloatBufferS); 
     156        kernels.setArg(2, clFloatBufferC); 
     157        kernelsw.setArg(1, clFloatBufferSW); 
     158        kernelsw.setArg(2, clFloatBufferCW); 
     159        kernelsh.setArg(1, clFloatBufferSH); 
     160        kernelsh.setArg(2, clFloatBufferCH); 
     161        kernelsw.setArg(3, w); 
     162        kernelsw.setArg(4, h); 
     163        kernelsw.setArg(5, d); 
     164        kernels.setArg(3, w); 
     165        kernels.setArg(4, h); 
     166        kernels.setArg(5, d); 
     167        kernelsh.setArg(3, w); 
     168        kernelsh.setArg(4, h); 
     169        kernelsh.setArg(5, d); 
     170        kernelf.setArg(1, w); 
     171        kernelf.setArg(2, h); 
     172        kernelf.setArg(3, d); 
     173        kernels.setArg(6, maxComputeUnits); 
     174        kernelsw.setArg(6, maxComputeUnits); 
     175        kernelsh.setArg(6, maxComputeUnits); 
     176        kernelf.setArg(4, maxComputeUnits); 
     177 
     178        kernelsh.setNullArg(7, h * 4); 
     179        kernelsh.setNullArg(8, h); 
     180        kernelsh.setNullArg(9, h); 
     181        kernelsw.setNullArg(7, w * 4); 
     182        kernelsw.setNullArg(8, w); 
     183        kernelsw.setNullArg(9, w); 
     184        kernels.setNullArg(7, d * 4); 
     185        kernels.setNullArg(8, d); 
     186        kernels.setNullArg(9, d); 
     187 
     188        if (DEBUG) { 
     189            System.out.println("Copying data to the device"); 
     190        } 
     191        queue.putWriteBuffer(clFloatBufferC, false); 
     192        queue.putWriteBuffer(clFloatBufferS, false); 
     193        queue.putWriteBuffer(clFloatBufferCW, false); 
     194        queue.putWriteBuffer(clFloatBufferSW, false); 
     195        queue.putWriteBuffer(clFloatBufferCH, false); 
     196        queue.putWriteBuffer(clFloatBufferSH, false); 
     197 
     198    } 
     199 
     200    public synchronized long run(float[][] data, boolean inverse) { 
     201 
     202        if (DEBUG) { 
     203            System.out.println("add the input data to the objects buffer "); 
     204        } 
     205        for (int i = 0; i < d; i++) { 
     206            for (int j = 0; j < w * h; j++) { 
     207                dataA.put(i * w * h + j, data[i][j]); 
     208            } 
     209        } 
     210 
     211        long executionTime = run(dataA, inverse); 
     212 
     213 
     214        if (DEBUG) { 
     215            System.out.println("Copy data to the float[][]..."); 
     216        } 
     217        for (int i = 0; i < d; i++) { 
     218            for (int j = 0; j < w * h; j++) { 
     219                data[i][j] = dataA.get(i * w * h + j); 
     220            } 
     221        } 
     222 
     223        return executionTime; 
     224 
     225    } 
     226 
     227    public synchronized long run(FloatBuffer data, boolean inverse) { 
     228        clFloatBufferDATA.use(data); 
     229 
     230        if (DEBUG) { 
     231            System.out.println("translate for inverse"); 
     232        } 
     233        this.inverse = (inverse == true) ? 1 : 0; 
     234 
     235        if (DEBUG) { 
     236            System.out.println("Setting CLBuffer to input data buffer..."); 
     237        } 
     238        queue.putWriteBuffer(clFloatBufferDATA, false); 
     239 
     240        long executionTime = run(); 
     241 
     242        if (DEBUG) { 
     243            System.out.println("Reading back data from the device..."); 
     244        } 
     245        queue.putReadBuffer(clFloatBufferDATA, true); 
     246 
     247        return executionTime; 
     248    } 
     249 
     250    private synchronized long run() { 
     251 
     252 
     253        //this changes every time 
     254        kernelf.setArg(5, inverse); 
     255 
     256        if (DEBUG) { 
     257            System.out.println("Setting global max and mins..."); 
     258        } 
     259        globalWorkSize = w * maxComputeUnits; 
     260        localWorkSize = w; 
     261 
     262        if (DEBUG) { 
     263            System.out.println("Writing the input data set to the device..."); 
     264        } 
     265        //put the data on the card 
     266        queue.putWriteBuffer(clFloatBufferDATA, false); 
     267 
     268        long executionTime = System.currentTimeMillis(); 
     269 
     270        if (DEBUG) { 
     271            System.out.println("Enqueing the kernel w..."); 
     272        } 
     273        queue.put1DRangeKernel(kernelsw, 0, globalWorkSize, localWorkSize); 
     274 
     275        //if( DEBUG ) { System.out.println("Setting global max and mins...");} 
     276        //globalWorkSize = h*maxComputeUnits; 
     277        //localWorkSize = h; 
     278 
     279        if (DEBUG) { 
     280            System.out.println("Enqueing the kernel h..."); 
     281        } 
     282        queue.put1DRangeKernel(kernelsh, 0, globalWorkSize, localWorkSize); 
     283 
     284        //if( DEBUG ) { System.out.println("Setting global max and mins...");} 
     285        //globalWorkSize = d*maxComputeUnits; 
     286        //localWorkSize = d; 
     287 
     288        if (DEBUG) { 
     289            System.out.println("Enqueing the kernel s..."); 
     290        } 
     291        queue.put1DRangeKernel(kernels, 0, globalWorkSize, localWorkSize); 
     292 
     293        if (DEBUG) { 
     294            System.out.println("Enqueing the kernel f..."); 
     295        } 
     296        queue.put1DRangeKernel(kernelf, 0, globalWorkSize, localWorkSize); 
     297 
     298        if (DEBUG) { 
     299            System.out.println("Waiting for CLFinish to return..."); 
     300        } 
     301        queue.finish(); 
     302 
     303        executionTime = System.currentTimeMillis() - executionTime; 
     304 
     305        return executionTime; 
     306    } 
     307 
     308    public double getExecutionTimeInNS(CLEvent clevent) { 
     309        long start; 
     310        long end; 
     311 
     312        end = clevent.getProfilingInfo(ProfilingCommand.END); 
     313        start = clevent.getProfilingInfo(ProfilingCommand.START); 
     314 
     315        // convert nanoseconds to seconds on return 
     316        return (double) 1.0e-9 * (end - start); 
     317    } 
     318 
     319    public static void main(String[] args) { 
     320        long time = 0; //used to track duration of ex 
     321        String path = "/home/loci/NetBeansProjects/i3d/"; 
     322        int d = 512; 
     323        int h = 512; 
     324        int w = 512; 
     325 
     326        if (DEBUG) { 
     327            System.out.println("Creating NIO Backed Arrays..."); 
     328        } 
     329        FloatBuffer dataA = ByteBuffer.allocateDirect(d * w * h * 4).order(ByteOrder.nativeOrder()).asFloatBuffer(); 
     330 
     331        if (DEBUG) { 
     332            System.out.println("Adding good data to the arrays..."); 
     333        } 
     334        HelperUtils.injectGoodData(dataA, path, "dataAswapQuadrants_float_512_262144"); 
     335 
     336        if (DEBUG) { 
     337            System.out.println("Starting opencl setup..."); 
     338        } 
     339        time = System.currentTimeMillis(); 
     340        FHT3DExample f = new FHT3DExample(w, h, d); 
     341        time = System.currentTimeMillis() - time; 
     342        if (PROFILINGMSG) { 
     343            System.out.println("OpenCL setup took " + (time) + " ms."); 
     344        } 
     345 
     346        if (DEBUG) { 
     347            System.out.println("Starting opencl setup..."); 
     348        } 
     349        time = System.currentTimeMillis(); 
     350        f.run(dataA, false); 
     351        time = System.currentTimeMillis() - time; 
     352        if (PROFILINGMSG) { 
     353            System.out.println("OpenCL execution took " + (time) + " ms."); 
     354        } 
     355 
     356 
     357        //HelperUtils.compareResults( path, dataA, "dataAswapQuadrants_float_512_262144"); 
     358        HelperUtils.compareResults(path, dataA, "dataAfht1_float_512_262144"); 
     359        // HelperUtils.compareResults(dataACopy, dataA, 10, "debugging"); 
     360 
     361    } 
     362 
     363    public static void makeSinCosTables(int maxN, FloatBuffer s, FloatBuffer c) { 
     364        int n = maxN / 4; 
     365        double theta = 0.0; 
     366        double dTheta = 2.0 * Math.PI / maxN; 
     367        for (int i = 0; i < n; i++) { 
     368            c.put(i, (float) Math.cos(theta)); 
     369            s.put(i, (float) Math.sin(theta)); 
     370            theta += dTheta; 
     371        } 
     372    } 
    318373} 
Note: See TracChangeset for help on using the changeset viewer.