From a7c4105a08f1c57278a059d449ef213eddfefc5f Mon Sep 17 00:00:00 2001 From: afedward Date: Wed, 29 Apr 2009 00:05:01 +0000 Subject: [PATCH] Updating CVS with partially ported benchmark. Sequencer.java's run() function is the last function to be ported, then compilation and testing. --- .../SingleTM/genome/Defines.common.mk | 36 + .../Benchmarks/SingleTM/genome/Makefile.seq | 18 + .../Benchmarks/SingleTM/genome/Makefile.stm | 17 + .../SingleTM/genome/Makefile.stm.otm | 17 + Robust/src/Benchmarks/SingleTM/genome/README | 95 ++ Robust/src/Benchmarks/SingleTM/genome/gene.c | 228 +++++ Robust/src/Benchmarks/SingleTM/genome/gene.h | 123 +++ Robust/src/Benchmarks/SingleTM/genome/gene.o | Bin 0 -> 7168 bytes Robust/src/Benchmarks/SingleTM/genome/genome | Bin 0 -> 113871 bytes .../src/Benchmarks/SingleTM/genome/genome.c | 285 ++++++ .../src/Benchmarks/SingleTM/genome/genome.c~ | 285 ++++++ .../src/Benchmarks/SingleTM/genome/genome.o | Bin 0 -> 13356 bytes .../SingleTM/genome/java/Bitmap.java | 212 ++++ .../SingleTM/genome/java/Bitmap.java~ | 212 ++++ .../Benchmarks/SingleTM/genome/java/Gene.java | 31 + .../SingleTM/genome/java/Gene.java~ | 32 + .../SingleTM/genome/java/Genome.java | 147 +++ .../SingleTM/genome/java/Genome.java~ | 148 +++ .../Benchmarks/SingleTM/genome/java/List.java | 256 +++++ .../SingleTM/genome/java/List.java~ | 4 + .../SingleTM/genome/java/Random.java | 96 ++ .../SingleTM/genome/java/Segments.java | 70 ++ .../SingleTM/genome/java/Segments.java~ | 71 ++ .../SingleTM/genome/java/Sequencer.java | 510 ++++++++++ .../SingleTM/genome/java/Sequencer.java~ | 510 ++++++++++ .../SingleTM/genome/java/Table.java | 57 ++ .../SingleTM/genome/java/Table.java~ | 57 ++ .../SingleTM/genome/java/genome.java~ | 1 + .../Benchmarks/SingleTM/genome/nucleotide.h | 93 ++ .../src/Benchmarks/SingleTM/genome/segments.c | 318 ++++++ .../src/Benchmarks/SingleTM/genome/segments.h | 128 +++ .../src/Benchmarks/SingleTM/genome/segments.o | Bin 0 -> 10056 bytes .../Benchmarks/SingleTM/genome/sequencer.c | 942 ++++++++++++++++++ .../Benchmarks/SingleTM/genome/sequencer.h | 155 +++ .../Benchmarks/SingleTM/genome/sequencer.h~ | 155 +++ .../Benchmarks/SingleTM/genome/sequencer.o | Bin 0 -> 18504 bytes .../src/Benchmarks/SingleTM/genome/staticTest | Bin 0 -> 6429 bytes .../Benchmarks/SingleTM/genome/staticTest.c | 15 + .../Benchmarks/SingleTM/genome/staticTest.c~ | 15 + Robust/src/Benchmarks/SingleTM/genome/table.c | 263 +++++ Robust/src/Benchmarks/SingleTM/genome/table.h | 142 +++ Robust/src/Benchmarks/SingleTM/genome/table.o | Bin 0 -> 6648 bytes 42 files changed, 5744 insertions(+) create mode 100644 Robust/src/Benchmarks/SingleTM/genome/Defines.common.mk create mode 100644 Robust/src/Benchmarks/SingleTM/genome/Makefile.seq create mode 100644 Robust/src/Benchmarks/SingleTM/genome/Makefile.stm create mode 100644 Robust/src/Benchmarks/SingleTM/genome/Makefile.stm.otm create mode 100644 Robust/src/Benchmarks/SingleTM/genome/README create mode 100644 Robust/src/Benchmarks/SingleTM/genome/gene.c create mode 100644 Robust/src/Benchmarks/SingleTM/genome/gene.h create mode 100644 Robust/src/Benchmarks/SingleTM/genome/gene.o create mode 100755 Robust/src/Benchmarks/SingleTM/genome/genome create mode 100644 Robust/src/Benchmarks/SingleTM/genome/genome.c create mode 100644 Robust/src/Benchmarks/SingleTM/genome/genome.c~ create mode 100644 Robust/src/Benchmarks/SingleTM/genome/genome.o create mode 100644 Robust/src/Benchmarks/SingleTM/genome/java/Bitmap.java create mode 100644 Robust/src/Benchmarks/SingleTM/genome/java/Bitmap.java~ create mode 100644 Robust/src/Benchmarks/SingleTM/genome/java/Gene.java create mode 100644 Robust/src/Benchmarks/SingleTM/genome/java/Gene.java~ create mode 100644 Robust/src/Benchmarks/SingleTM/genome/java/Genome.java create mode 100644 Robust/src/Benchmarks/SingleTM/genome/java/Genome.java~ create mode 100644 Robust/src/Benchmarks/SingleTM/genome/java/List.java create mode 100644 Robust/src/Benchmarks/SingleTM/genome/java/List.java~ create mode 100644 Robust/src/Benchmarks/SingleTM/genome/java/Random.java create mode 100644 Robust/src/Benchmarks/SingleTM/genome/java/Segments.java create mode 100644 Robust/src/Benchmarks/SingleTM/genome/java/Segments.java~ create mode 100644 Robust/src/Benchmarks/SingleTM/genome/java/Sequencer.java create mode 100644 Robust/src/Benchmarks/SingleTM/genome/java/Sequencer.java~ create mode 100644 Robust/src/Benchmarks/SingleTM/genome/java/Table.java create mode 100644 Robust/src/Benchmarks/SingleTM/genome/java/Table.java~ create mode 100644 Robust/src/Benchmarks/SingleTM/genome/java/genome.java~ create mode 100644 Robust/src/Benchmarks/SingleTM/genome/nucleotide.h create mode 100644 Robust/src/Benchmarks/SingleTM/genome/segments.c create mode 100644 Robust/src/Benchmarks/SingleTM/genome/segments.h create mode 100644 Robust/src/Benchmarks/SingleTM/genome/segments.o create mode 100644 Robust/src/Benchmarks/SingleTM/genome/sequencer.c create mode 100644 Robust/src/Benchmarks/SingleTM/genome/sequencer.h create mode 100644 Robust/src/Benchmarks/SingleTM/genome/sequencer.h~ create mode 100644 Robust/src/Benchmarks/SingleTM/genome/sequencer.o create mode 100755 Robust/src/Benchmarks/SingleTM/genome/staticTest create mode 100644 Robust/src/Benchmarks/SingleTM/genome/staticTest.c create mode 100644 Robust/src/Benchmarks/SingleTM/genome/staticTest.c~ create mode 100644 Robust/src/Benchmarks/SingleTM/genome/table.c create mode 100644 Robust/src/Benchmarks/SingleTM/genome/table.h create mode 100644 Robust/src/Benchmarks/SingleTM/genome/table.o diff --git a/Robust/src/Benchmarks/SingleTM/genome/Defines.common.mk b/Robust/src/Benchmarks/SingleTM/genome/Defines.common.mk new file mode 100644 index 00000000..d8a356b9 --- /dev/null +++ b/Robust/src/Benchmarks/SingleTM/genome/Defines.common.mk @@ -0,0 +1,36 @@ +# ============================================================================== +# +# Defines.common.mk +# +# ============================================================================== + + +CFLAGS += -DLIST_NO_DUPLICATES +CFLAGS += -DCHUNK_STEP1=12 + +PROG := genome + +SRCS += \ + gene.c \ + genome.c \ + segments.c \ + sequencer.c \ + table.c \ + $(LIB)/bitmap.c \ + $(LIB)/hash.c \ + $(LIB)/hashtable.c \ + $(LIB)/pair.c \ + $(LIB)/random.c \ + $(LIB)/list.c \ + $(LIB)/mt19937ar.c \ + $(LIB)/thread.c \ + $(LIB)/vector.c \ +# +OBJS := ${SRCS:.c=.o} + + +# ============================================================================== +# +# End of Defines.common.mk +# +# ============================================================================== diff --git a/Robust/src/Benchmarks/SingleTM/genome/Makefile.seq b/Robust/src/Benchmarks/SingleTM/genome/Makefile.seq new file mode 100644 index 00000000..e143931e --- /dev/null +++ b/Robust/src/Benchmarks/SingleTM/genome/Makefile.seq @@ -0,0 +1,18 @@ +# ============================================================================== +# +# Makefile.seq +# +# ============================================================================== + + +include ../common/Defines.common.mk +include ./Defines.common.mk +include ../common/Makefile.seq + + +# ============================================================================== +# +# Makefile.seq +# +# ============================================================================== + diff --git a/Robust/src/Benchmarks/SingleTM/genome/Makefile.stm b/Robust/src/Benchmarks/SingleTM/genome/Makefile.stm new file mode 100644 index 00000000..5206ffff --- /dev/null +++ b/Robust/src/Benchmarks/SingleTM/genome/Makefile.stm @@ -0,0 +1,17 @@ +# ============================================================================== +# +# Makefile.stm +# +# ============================================================================== + + +include ../common/Defines.common.mk +include ./Defines.common.mk +include ../common/Makefile.stm + + +# ============================================================================== +# +# End of Makefile.stm +# +# ============================================================================== diff --git a/Robust/src/Benchmarks/SingleTM/genome/Makefile.stm.otm b/Robust/src/Benchmarks/SingleTM/genome/Makefile.stm.otm new file mode 100644 index 00000000..7dc12e57 --- /dev/null +++ b/Robust/src/Benchmarks/SingleTM/genome/Makefile.stm.otm @@ -0,0 +1,17 @@ +# ============================================================================== +# +# Makefile.stm.otm +# +# ============================================================================== + + +include ../common/Defines.common.otm.mk +include ./Defines.common.mk +include ../common/Makefile.stm.otm + + +# ============================================================================== +# +# End of Makefile.stm.otm +# +# ============================================================================== diff --git a/Robust/src/Benchmarks/SingleTM/genome/README b/Robust/src/Benchmarks/SingleTM/genome/README new file mode 100644 index 00000000..8960be62 --- /dev/null +++ b/Robust/src/Benchmarks/SingleTM/genome/README @@ -0,0 +1,95 @@ +Introduction +------------ + +This benchmark implements a gene sequencing program that reconstructs the gene +sequence from segments of a larger gene. + +For example, given the segments TCGG, GCAG, ATCG, CAGC, and GATC, the program +will try to construct the shortest gene that can be made from them. + +For example, if we slide around the above segments we can get: + + TCGG + GCAG + ATCG + CAGC + GATC + ============= + CAGCAGATCGG + + +This gives a final sequence of length 11. Another possible solution is: + + TCGG + GCAG + ATCG + CAGC + GATC + ============= + GATCGGCAGC + +This solution has length 10. Both are consistent with the segments provided, +but the second is the optimal solution since it is shorter. + +The algorithm used to sequence the gene has three phases: + + 1) Remove duplicate segments by using hash-set + 2) Match segments using Rabin-Karp string search algorithm [3] + - Cycles are prevented by tracking starts/ends of matched chains + 3) Build sequence + +The first two steps make up the bulk of the execution time and are parallelized. + + +Compiling and Running +--------------------- + +To build the application, simply run: + + make -f + +in the source directory. For example, for the sequential flavor, run: + + make -f Makefile.seq + +By default, this produces an executable named "genome", which can then be +run in the following manner: + + ./genome -g \ + -s \ + -n \ + -t + +To produce the data in [1] and [2], the following values were used: + + -g256 -s16 -n16384 + +For running without a simulator, use the default values: + + -g16384 -s64 -n16777216 + + +Workload Size +------------- + +The size of the workload is determined by the -g, -s, and -n options. The +gene sequencing example in "Introduction", would correspond to -g10 -s4 -n5. +In general, the values for these three options should follow the following +relationship: -s << -g << -n. Larger values increase the size of the workload. + + +References +---------- + +[1] C. Cao Minh, J. Chung, C. Kozyrakis, and K. Olukotun. STAMP: Stanford + Transactional Applications for Multi-processing. In IISWC '08: Proceedings + of The IEEE International Symposium on Workload Characterization, + September 2008. + +[2] C. Cao Minh, M. Trautmann, J. Chung, A. McDonald, N. Bronson, J. Casper, + C. Kozyrakis, and K. Olukotun. An Effective Hybrid Transactional Memory + System with Strong Isolation Guarantees. In Proceedings of the 34th Annual + International Symposium on Computer Architecture, 2007. + +[3] R. M. Karp and M. O. Rabin. Efficient randomized pattern-matching + algorithms. IBM Journal of Research and Development, 1987. diff --git a/Robust/src/Benchmarks/SingleTM/genome/gene.c b/Robust/src/Benchmarks/SingleTM/genome/gene.c new file mode 100644 index 00000000..60e0e9d4 --- /dev/null +++ b/Robust/src/Benchmarks/SingleTM/genome/gene.c @@ -0,0 +1,228 @@ +/* ============================================================================= + * + * gene.c + * -- Create random gene + * + * ============================================================================= + * + * Copyright (C) Stanford University, 2006. All Rights Reserved. + * Author: Chi Cao Minh + * + * ============================================================================= + * + * For the license of bayes/sort.h and bayes/sort.c, please see the header + * of the files. + * + * ------------------------------------------------------------------------ + * + * For the license of kmeans, please see kmeans/LICENSE.kmeans + * + * ------------------------------------------------------------------------ + * + * For the license of ssca2, please see ssca2/COPYRIGHT + * + * ------------------------------------------------------------------------ + * + * For the license of lib/mt19937ar.c and lib/mt19937ar.h, please see the + * header of the files. + * + * ------------------------------------------------------------------------ + * + * For the license of lib/rbtree.h and lib/rbtree.c, please see + * lib/LEGALNOTICE.rbtree and lib/LICENSE.rbtree + * + * ------------------------------------------------------------------------ + * + * Unless otherwise noted, the following license applies to STAMP files: + * + * Copyright (c) 2007, Stanford University + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * * Neither the name of Stanford University nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY STANFORD UNIVERSITY ``AS IS'' AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL STANFORD UNIVERSITY BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF + * THE POSSIBILITY OF SUCH DAMAGE. + * + * ============================================================================= + */ + + +#include +#include +#include "gene.h" +#include "nucleotide.h" +#include "random.h" +#include "tm.h" + + +/* ============================================================================= + * gene_alloc + * -- Does all memory allocation necessary for gene creation + * -- Returns NULL on failure + * ============================================================================= + */ +gene_t* +gene_alloc (long length) +{ + gene_t* genePtr; + + assert(length > 1); + + genePtr = (gene_t*)malloc(sizeof(gene_t)); + if (genePtr == NULL) { + return NULL; + } + + genePtr->contents = (char*)malloc((length + 1) * sizeof(char)); + if (genePtr->contents == NULL) { + return NULL; + } + genePtr->contents[length] = '\0'; + genePtr->length = length; + + genePtr->startBitmapPtr = bitmap_alloc(length); + if (genePtr->startBitmapPtr == NULL) { + return NULL; + } + + return genePtr; +} + + +/* ============================================================================= + * gene_create + * -- Populate contents with random gene + * ============================================================================= + */ +void +gene_create (gene_t* genePtr, random_t* randomPtr) +{ + long length; + char* contents; + long i; + const char nucleotides[] = { + NUCLEOTIDE_ADENINE, + NUCLEOTIDE_CYTOSINE, + NUCLEOTIDE_GUANINE, + NUCLEOTIDE_THYMINE, + }; + + assert(genePtr != NULL); + assert(randomPtr != NULL); + + length = genePtr->length; + contents = genePtr->contents; + + for (i = 0; i < length; i++) { + contents[i] = + nucleotides[(random_generate(randomPtr)% NUCLEOTIDE_NUM_TYPE)]; + } +} + + +/* ============================================================================= + * gene_free + * ============================================================================= + */ +void +gene_free (gene_t* genePtr) +{ + bitmap_free(genePtr->startBitmapPtr); + free(genePtr->contents); + free(genePtr); +} + + +/* ============================================================================= + * TEST_GENE + * ============================================================================= + */ +#ifdef TEST_GENE + + +#include +#include +#include + + +int +main () +{ + gene_t* gene1Ptr; + gene_t* gene2Ptr; + gene_t* gene3Ptr; + random_t* randomPtr; + + bool_t status = memory_init(1, 4, 2); + assert(status); + + puts("Starting..."); + + gene1Ptr = gene_alloc(10); + gene2Ptr = gene_alloc(10); + gene3Ptr = gene_alloc(9); + randomPtr = random_alloc(); + + random_seed(randomPtr, 0); + gene_create(gene1Ptr, randomPtr); + random_seed(randomPtr, 1); + gene_create(gene2Ptr, randomPtr); + random_seed(randomPtr, 0); + gene_create(gene3Ptr, randomPtr); + + assert(gene1Ptr->length == strlen(gene1Ptr->contents)); + assert(gene2Ptr->length == strlen(gene2Ptr->contents)); + assert(gene3Ptr->length == strlen(gene3Ptr->contents)); + + assert(gene1Ptr->length == gene2Ptr->length); + assert(strcmp(gene1Ptr->contents, gene2Ptr->contents) != 0); + + assert(gene1Ptr->length == (gene3Ptr->length + 1)); + assert(strcmp(gene1Ptr->contents, gene3Ptr->contents) != 0); + assert(strncmp(gene1Ptr->contents, + gene3Ptr->contents, + gene3Ptr->length) == 0); + + gene_free(gene1Ptr); + gene_free(gene2Ptr); + gene_free(gene3Ptr); + random_free(randomPtr); + + puts("All tests passed."); + + return 0; +} + + +#endif /* TEST_GENE */ + + +/* ============================================================================= + * + * End of gene.c + * + * ============================================================================= + */ diff --git a/Robust/src/Benchmarks/SingleTM/genome/gene.h b/Robust/src/Benchmarks/SingleTM/genome/gene.h new file mode 100644 index 00000000..b4fa2db1 --- /dev/null +++ b/Robust/src/Benchmarks/SingleTM/genome/gene.h @@ -0,0 +1,123 @@ +/* ============================================================================= + * + * gene.h + * -- Create random gene + * + * ============================================================================= + * + * Copyright (C) Stanford University, 2006. All Rights Reserved. + * Author: Chi Cao Minh + * + * ============================================================================= + * + * For the license of bayes/sort.h and bayes/sort.c, please see the header + * of the files. + * + * ------------------------------------------------------------------------ + * + * For the license of kmeans, please see kmeans/LICENSE.kmeans + * + * ------------------------------------------------------------------------ + * + * For the license of ssca2, please see ssca2/COPYRIGHT + * + * ------------------------------------------------------------------------ + * + * For the license of lib/mt19937ar.c and lib/mt19937ar.h, please see the + * header of the files. + * + * ------------------------------------------------------------------------ + * + * For the license of lib/rbtree.h and lib/rbtree.c, please see + * lib/LEGALNOTICE.rbtree and lib/LICENSE.rbtree + * + * ------------------------------------------------------------------------ + * + * Unless otherwise noted, the following license applies to STAMP files: + * + * Copyright (c) 2007, Stanford University + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * * Neither the name of Stanford University nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY STANFORD UNIVERSITY ``AS IS'' AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL STANFORD UNIVERSITY BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF + * THE POSSIBILITY OF SUCH DAMAGE. + * + * ============================================================================= + */ + + +#ifndef GENE_H +#define GENE_H 1 + + +#include "bitmap.h" +#include "random.h" + + +typedef struct gene { + long length; + char* contents; + bitmap_t* startBitmapPtr; /* used for creating segments */ +} gene_t; + + +/* ============================================================================= + * gene_alloc + * -- Does all memory allocation necessary for gene creation + * -- Returns NULL on failure + * ============================================================================= + */ +gene_t* +gene_alloc (long length); + + +/* ============================================================================= + * gene_create + * -- Populate contents with random gene + * ============================================================================= + */ +void +gene_create (gene_t* genePtr, random_t* randomPtr); + + +/* ============================================================================= + * gene_free + * ============================================================================= + */ +void +gene_free (gene_t* genePtr); + + +#endif /* GENE_H */ + + +/* ============================================================================= + * + * End of gene.h + * + * ============================================================================= + */ diff --git a/Robust/src/Benchmarks/SingleTM/genome/gene.o b/Robust/src/Benchmarks/SingleTM/genome/gene.o new file mode 100644 index 0000000000000000000000000000000000000000..c4b94f87472981eb42aedb2b564c60e371f05d42 GIT binary patch literal 7168 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 literal 0 HcmV?d00001 diff --git a/Robust/src/Benchmarks/SingleTM/genome/genome b/Robust/src/Benchmarks/SingleTM/genome/genome new file mode 100755 index 0000000000000000000000000000000000000000..8f88639c174cb71f12318f7d7d8026e3016f873d GIT binary patch literal 113871 zcmeEv34B!5_5XX5H_1#gAprse2r!Vaggt=DrXn~j3KoF?iXj9NNHiodnNhH^8KR71 zFz!@Q!L8c5P#4_L215zBMnpuR7?;+GV4GG2RBHa;@44^I60p@@`}_6x`}{lk+%6S;Or5Cfx@LWBT8u_$dcbgu!1K}DRoV#6t;K2mv_4w877IMnMyv)6 zLL=e~b_4?<1|bD(DQgS|LwmpsOrta<5fSh*lwG804CL36Rl4AskcO}c4AYS*^JTgX zkF}s*i!_F2zzj@h9t{1!(+_zwxB)X*X&3&%n-B1$kHtTvxM<;!;`~9yMJ2vvgDXl0 z4^zCzT6CXuLALNx5Arw=dL#5j=!Vc8p&dfxrwf1%2((RlL_$ZzDK`!wB?6y@cv}eC5KKHW@z$%IFm=_^fmq6r^2;ZIDMeEfWgK=}s=;B!9$;qwXLL%j))B7o1i z2!wAj`KOrh=2rPtneY>4`fDakIpqHn0zYp6Pk5I=nzkQL!mpb2Y*&OIHesJhUjrOJ zrD%jqUn-EMZ9>HpW;yt&GwClg`ENAgOH9}*|A!_#3q0hXW5VB>@H2Swvj&0bcOre< zVZ*_8*A~6y9KciGvEU?aE8vWX^!>sL)J;+$9Cxin4-5MT?6Tg>ZRZZ+UJ}Ns%{%S?co^EX(zk z6qhc#EQGwYw5TKmEJAkPf-qQGlAl{qw4@}jID}I|qC_kr*_C+_IbBw;Jhzpsic_d4 zjHgghP$++eH-FK90WALMT5j%=rKKgg72dpZZ*DHFvs5J@wq((w+zLWj#4j=#ru+=l z`9&qUzKVi;ZSmq_Uqzu-uncNec*{!`EiKbZ%e+M;`C6IJTLJkrDP%9sD=H?1w^Sa* z1tr?jf~8PjgO$O7wER+^m&iqB%eAF>#V`g%<&`gCT0wa^DZNEY3rZK~=PlP3mz5Wl zco%DzSCp1}Nk|H0Kn-$psjyk9rFp1|#pMMB+N7yd#!tu{hFZ5`S)tf)ju7-=F??X0 ziNPNs>(2mW4?#9FjW|VX(d!`^9V5*dXn!0V+z81xe7wT!da{Xl+ec@!LZD-p>t3EYxLtx5JUKU)a+%=|A?Ks$baA(b@j(7(~{BJ`NeK z;}bG(;1m2ceA+ebRzA`1H}HwUY$Kl-s5bElO&;JA1IELAVgPxRPYhUF_(aK`<`V_EiGg)5pBPN{^N9iQAfFg88~Mb*^eLYh zgoAuy5Iw>t2H9plF=&6qCkF20d}2U7!KYi(vi*OUS$V_=(#G@F)J@IPw7@MVT3TAF z_IT~Vvw#g2!5qP-;dJND+g;ak+STA}>Af1?qm zWlgmL)1rmYTx;4QFfCi?CcH^tTDY(u;TnNA5*|u;wZOD^A%~o%GJ$FN!f}Kb2+SHN zoJ@GSz^sYF>4e7#%o-`2OL(ZjteL_EgxvzOh6-7rreuM)5iTRF3CtQRTt>M0dmwtV z<_cF6ZWNd`Sh$XGgTSoG!WzQ00<%U7HxS+;Fl)AO6X8t)vxW;FCR`)%LBd-IuNIg! zUicj0GJ#q1g|&ni2+S5xxQp;~f!PuY8wigRm@T4kKjEPQvt<-E5_SvB7E%}_oGkDO z!p(#=z*%3+_kUFRY4h}1GYV_=AY~K2E}UIBuG(+}&j!I)HBle5ugW8i)n`scKhwOf z!)cYZ#{CWeEqgZe5lF7u<2$_5&UAfuU5%pOyc*Nqs#KC0Z2HgA4zPF?-E8Lpd= zf~TVjO5$luCv0TQ!6P^m`9;!P8%wtfM02DdL{YP@@{B_k6b!z;!B>N{A-a|W$p_+fVe?&$w4d$q-^-pm4 zUOQY*eeN@Lz9d?o>!{DY==f3E)YMc@%`i~iEtj8Amb$jHE`z!an2&Zz~2X!Z6> zzCdgoW6Kyr)IaT@e^=iuS{QNNX=5Z#&b=>r{D)Ic|u-|yMAnZ@;IzfPh3&qUQdgP{l2;Au!& z>x3}it?~rF?S%%Lz004H5o}R4Sf8}E7CtxNX@G@jsNh5-1m+n2?7jX=GK_#n1h>U7 z1erUN)|QYuy8%-DSHrBcG91Aj%*C4lySz>bW(MCY7SH~qwH?8OGG**VnchP&0&#%) z1Ck6q#KZz~j)fUc%tSHM!)FWYTq`M+RUylZ^V#O?P-jp>Z~M+rh|~x0Z-!r&!_L(Yfv2rzj^=FL)#B{f(JZD4t)th zmB{zdD~CS%J?s=*6`8+{nPu+}bWtYUO9j3Mjurff*}y&lH-y|w<;O=d|Lz;OlC+Fq zHz56W0grGe0~l48bj>fxZDhPgE>|Sijo?C-tlAXJ9oQcaqH(j`pG$M1f}zByp5dC9 z7Rf#x?7;w5FO@q+X4PIqw^N;WqK>w?F+$N_NG^M!!DGOp_Ko1RR2LQiZX30_0&vq1 zj8@=v`C&Ia9W7>|Kcz=7G78zc?>-()^FcI?gTj`#qIoZx<_mg~>{c{;qG`lKX0@Vu zGnz&`WFlzLc>^{m_?GE5f)A4shNCiRC>af+jT0lf-vw@+5)5}Sj`cE~IIoEV8F8zL zTVUeEFButIh?}Zpf5Jl4s(2&uPpi0_Ml$m!Tkv(@BVDE%k5VumiB=#n$ED$8rP~KD zJBAXep{fRLJupE=n`~fZs7k?5H5oun_0xU892&32V!Yy5RhzW73O%=KPtw|p@C-~# zuG*cn_I5@mI|5fZ{L}UaCcEH%1CGEr!#}Oj@A)(^-UzhwdxDj(=$WtjvyTL_Kdsuc zvLx#${AD0JnawjBQ^Tx1Xqd-*NBr+d8@d^@Rc7}l${Bz>PcV@3o4~Y2eZTnblnnpW z3`g+9QB^_6)_BtIQts*)%1YK!u)^Jr@qOyM!!idO|1neaTQra7NLB61NdZq|*3m$A zV`Wf>nto3+d|hB#b9GvqF*!$8#sqSXjQVnw^Kf5?8+FLr3$9IukHaq)RkvC&_*(?~{kLHbAZWxZKE-591$+t1zt^@C$g)eE7zmB~8H z-!bmqg(A2fGCR+!P@P4(m9UXC}yOWgR zOzX!edv!vlk#Onp>l3#0gAqMRR*JjdbvVt!OxLZCx}+E1IWHLG$UCC_ct_^uNj@si=`;5cz$_ z{W)LxSDXkw0}&i6eQnj`>3AULtH6pAYW{>7-}XiuUGaKFHqqtXkN(Dr^fV(i=?Sz) zB$rCEcUxeEtEy#Xn*Wu+L|4}CzzT;yWnJZVeW%e$i^*;tGtK2Y3@+j)8ve7$`SnQF zuz#Y%x2EYT_~DStfWDlLCS$r6n3zh^51i-}6H^#H8-=P|nWnGo@giD=Ci9nx$pK>n z=Aul00;Hqnr>*)tFfo~M66m24qXwdWALhQv^XBI?9sMh;!)-rhpOLVS8vrar`}mFr zZv#2>tM_%P_i*mdenJ!Zj$2j&?4eJSMG;#N7ejbDYB6-P#u_<Wu~#wf@`&gHQN^G1*6a zP2nm!jG{pHq~xTv7ea%|6)t_{x%HlAF%bNjuNhfVAC_YKA8qtWU&iDn2YbO-{+Pg| zR4TbJD2dHD*RBNo#}Xe}U{HaGGPX_5`N6pjEx> zPSlT+Z0g6!MA$#hRX>jHPV0U=hXqMZTDwlI{t!IZbE4PlREtZ`K@n6uiOT4n|d=0Z=)<=J4OPj1drwa|A9j0y9$mRbEAdipgFZ7?PVANIXPL93n(<_|#@w^0=iPqSgwK(#0~#qfJJ zR_*pr+mN*W1yp*yr-pW__dLLdVhK#E3D^S0I=|;p`uJ+qdvD^(aN45^!r)~D@0G<- z(%OZP6UctFdRjAE3nx&&BW?C-*t@D&%<%vkM)la_z$62!#`J*afxxuY^bfCW|F*}m z6&w8xlI{pxiAnkcRY!fl4+tZ?%_Jjf>o|RFt+#)mnzE8!Zt(Bl-WXeL*!&-C|2SE1 z$lUL*OWJyl4ZUP-Es}j7R<5`~_vbp2*3;FQl8%ZG!1##ug_2aX^K7)jq?czUv|!%v zs2-6VxQ+G7aVuclNz=YzXCw2T4~H=(=LWXH8;bUkD==*rd6HhnvaEqd3V7C%VWTi4 ztsRB+14P^dtX8j;z{IzK!)B&LXs=^(!TB3a=j9ESAml!>#YlI)K_i-NZ~r-E8|QnPhLH zfLjN6ZuMX6P$h)#I`>s$<(2&Q`)-Z7(trx9)&)GbVwh5e9pJmw@70aqd;MXcr42@< zXRltl6o#t$ITqx>TA%~Zh!u}|r>@ySpBvg6vbxCKFl6g4a>ijc;ajDDC}oVR)w zz_X*$vmZTvW2NVH_o(dszMBHo6uA>4d()frBu2&vIFjI8C_Tz|u;LBa$z|Cs51l{4 zZkLd-rAbX*EgC)Awy$s!exMc2SJ5<0qtj|pd~b8w zgM{(M;TvE_&WEOPDpa+5S^5~qiXQ$~D?jS7{d4>Fk8Ls29nx#wX>{5ol2ccclT};S zdOr2{_|Ys|-l^^Rphvh-ooU9fonF{6Ls(NB0p~3%lggUTC<#E08!xs3gQ6Km|@*fw~%=H?T znQR26qe@r0vTBc|Tmxq|YM1Y5PTgX2Kb#X()S7LK?&}^H?+DB=0#mryK&6ZK;bgA- zk1Z{`>*zv$hkl2rgXigVAvX~=G9F-e-1di)=GRy+QibUTs)FQfnU-L5z>C3wLx*sG z<#}27yx}e+hYlImQ@Wa%S8wY}L8!lI`pY8e=bwsxcGgi@5n>C;P#gcpK!z@HmOs_M zGpqJ!T@QGJ?T78yiJ53rr&Tc@Zca7`85Wt|ZrIKUm4#m9wokFx*^%sT#%iz*&N}O8 z@MEA3ABKJ?KTaBOL;HW{JGpJs~9Sz6BJ^V3LVX4CorxfGC)Ke*e z!C*v2aI(^4g2Vd~ran=6BqGzu!wc!pXg@47+Rw66w4dwHrBwSlWVN5nFUSMTx#!IopWgHZjTam~y+pqRUXtf+1r zCdm3OH7$=|XBU7=iTa5B`oVr^5prtdf(2S;I?xAv&BrQa?ZMe~jOor@SnFi%L1o6U z!NIZ(v@wox!tJZ_$WM^B4I5w(10ga-KoW-ubo6lh!-)+XIrUp{0y`I2?guKkd8V{n zain_1kz+@p;D{PIJwOF6flz-PW()_=l6ay3T%Fo!>%xY%1WRc(d5IhW*!4a&yWRlI zO4*m*R$WiF$Ikf}BjHcA*Fl`6|10fv1LXb7?R5r(wzk)o5%!vc!SvMjI%e7{{uK6V z`%&0ls575S>JO)aUj=emB`tHLl^r?uWwqysEaBqV$Z#T-5quB_hG=AMF=fOC589Zu zj}!1DgO$|5x7A_LPVWa6^9HiMio$SV4SwG%toh}j%i42zYfWf>tsmRaPtvDD{6E%b z^Qrau7KV({$Jt6B8GI^_xMT|r%k!0;;kaVMyJUW}R=s}Id}CEpR``5fE~&8-YGb=FNDe4nr8GH_tN-ZdNF5`J<$ZyQvMGrKi8LasUC4JW}p*KV0Kyg zC%Gli1?_9phupC}Qcv+boDKf&_aQA{2h#```mjal@Q)0vNb$pa<2a_pKOM8vWURiI zbr1Mb1KBB6NBz^2mvswdr~0R3Js!zh?@2*7*A8Q8bfn&sD)IMDKL1ztwe0a-Sd+hF zk9R@!~L9~vQxz%IuX603T?=%i)1Y)rh!*-pLQCV+P?li>VZNk)U zOwK{?`P@-W4y26sXE$=er8ahgzdPEpa^ zsXT_JF~)b$n~4Ll>a?@Cmj{P!CdMl@cR~l#hu}5}fUH_k=;ZcfYNFL+b;=!eXyivx zJg%Ik^~mTX|6}UURnk9aZ#Rqa!}jipA)=oG4*wsot#dv`I{r5x53e2B!n)Fy3k8^ zpEUoCpkMzJ>F1w{KB|B+-@_4*qq=4X#!=k+k zjA46#nd#Fpbvbo9+>ni%0de=_DaNw>-#lnEm*c7HG36)vyP zhhcL*vBJS=?f2L^Og!8j+lpwn-TjBS-gL?QGzN_ZQ{JlDWgiDPGxEh_ST>#BNi@Ds zaM4RmT~2E6=6W1W1Tz#Zc;`MWNngQYXOFiV&b%6wo2(xXH;XmQcub^m4b6#d<4WEm ztg9dIsCm*b0ok8uCGWg{vAl2J{U`PNVf!xnA^UO~?9XoYwzmw+({VArceLeO7D6x7 zQGYbo%1JJr{-qiI1zQp@e0XH?A2Mfihv7l3`ifeg{;+=kJ@qg7rQvk`r1qBeL-t^M z3mYTU61^^*ZtY0(H^|7#t?-FP{RC+^Tqdu62ear&E?K>zApbi^ar1zacF=YK-qhCM%|?-{1P2T!5zrQrJa= z>C4+1C$)!vs(*}!cK^-&{D-^84G%+nz19^Gt5}Cw-=6L(fyLqzk=1=%tqJh-Jlkz zm`8MxsN5<^l4y{#3qzuxGWyM1q-|vMPZB-I=qHHsF4_S;vE+S+Ns-%GYM4{=lhA!^ z8F`c{HdB>5DZuAYn@ZS!Yw{BjF<<$2*vHP&sA~`3zR9TA=g$%q`+O=M!8ZGvZ#lvCeT->Cz09?_ z-QM~<#2W8q!!GX3Qg9?)`!zhnnU^!V_9&f1_pIGAKgMCfCF_meK&|$Fum(HGEvuXj z{#S4!@b>4!Z(TnE_mYOER85D!_ouAKt%5b*d;(hEuE0GvU?I7<<{$8TPqehO;-@~~ zzjhmz3yYt}O_`38d+WS!9~zPM?IgxttI^S)B-2jZ3;H}E>lI!LitD|4_Q1Qdp!D{S zlh%B!X*>Tc3Bh(*4OqEXr^wMs^<@2UEf*t~;~>M@b6iET=}T?9D#hT2G=FB zk6_Xga9vlO_AIw3Jjs=wBYI3q4es%&s!v?pSsNaszq00g+RWd6Wn$nu8bSp5ovd4e>`i?c8ur8XYgsK-@tgZKd}&1Gh_SV*qJ~a+P*)rSekySawU^- z!|U1~q2ZcuWT18=Rn10;SrIbM|6AupfsU9n&~X27YLr#$mzryO2yG5F47EobLSrL1 zxDmgEX}SluDXsm{%`X17@(=K};znit<=DK;{K4fH+j$u$djC`WD}T=$7+WN83G=9)T>Lcg#VxW3^KFq{^5LuQYwC2ERY{qN~ zz2(||&E`VD7FGCe!b>ls+=o_u6teeJWVX4Ow02ejL`$PMjc5^JXQGAfPWA1?6H{+z zrc}qgW`Jr#{}Fqkwo+9uVgrGxD#40P^gf5rm37u;FIa(Z=}?AA; zRWS?v^`AExmgJcV$}6r>#qS|vvI)6M>z$ntY-BSvQV@GF5cS;C~MMidge zOY5J;vwBiX)$yb%zWm33+-wIsVOIVCu{)8=u4W6ppW+t(Ks#Lw`d01qlb24_PTv5Q z?bK2q?TD@^_$~wlI)_)}_l8S=eVN2OY! zY}HIE3v#C@e?MzAX>AuE*;tuL88WYI(Y+JYuffzbGewTQdDh(!(}6rO(n6r1Lwij% zIWnVDyLiv`br#^mRl6*w5^iSTaOId?r4j{T5zVf$p55S@ZK|tSH0z>i`hhh#-=wj+ z+^M?L=vFkR>Xsc_<+Ua{FN1mg6*pTWb-p>8<}K>{W-A*0R4Afczah=9TG3n|O|ywK z*McU}Ut+MipZx?Ai2K=bC=+a2Xq@V;3ZRf|d2HwWJ-69!eCg4BqTVArW2&2Z9J`w` zK+9KMp#Ng@sM@nUmUn^|*C6LH$t%9ZRaM?L#(i*HG{okNBY@+Dl?j0h9T>X&SXf_^ z<8PqbCcm5yhR0LD>Y|Hzzn14$Xkt_#SdD^Wcec*w;K3!&yFd-e{qR}|TF&pNpsDF;7?-;VT`k@5%qSoy|}moN8M<$fdfpmD{q{g|1Cw=aIJ zhASg}S55VJ-5(=rMQ^W}+foKQt5!X>9ZR+T1-N=#vBgg!_V|Bp1jb-|>lrv7_v`}3 zO@8BccG+)zU-HL1_dkyw-`-#0ID8uj4j&1RPya%FzDFiMQlIues1NOr@zVU!`Qhgv z(t0V%Apj@s&qdR}7)k&5spzr4jea0k0(m)+Rgj9?Z!3o22!I~h=3gPdp3P!m>iIhq z?-=t<67wOC6X})wr7U(Fs+BiGYT#%59TdBb{8H~W5K0~TyGPZcd7t!0<^LO&Bs%{? z&;H2#JN(`Jaqo++0A4`e%|>4vuyGoNyXtIKpKVp08FO6pM@((8Q5QbH$9Na~8QS2Q zx;OA!3~apwmw>+d#pB=OyOQ6T_1jx)FdMFI^Hv+OVSyE3d8&okZq`dv|4l<)4JIW$u%&nw9X|T=hn?C8JA5SB&Wf+ZxaIE4Zg1(*8@N){EApCT>46lKyTK@Yd7ryHL$-Mx#8 z;G;jxW!U~2fMXdcrBZxFOJtrN+D2b;$E8PT~t_5 zA%v=QWMS5%Mqw?TP4L_Tu~HshAh*PgSHYE*FCR?#%kfq|E&gX>u8PsZ|98InJ+5B*Ea@d7=!x759;bZJ>}fw!P|Iign(2jNnUnl^!~ zR<*j(%tJ+$I^fIo(02M+RhH>K>rA(aql8Snv=49E!zaT##WE6GtT)f=t3XYwhHLc; zOH6rmqb7N|cS30iB>NV5Jtf}q<+%kV`DoJ`9<36Dm`Rp2W?xcpPz|2tg<+?la~I~7mlugEvM`E%N`6H&qJqYVbg-rX zMUHN-^$Tav#~lF-a%W{`l6$CTi45o3S}Np335Fi6NmP!O=BB?kkxkzz zz;s~Uu*rjKd-6_5oSeyrW7RUewT}BgJnX?QBITX37|*nR>kJ3qFMIqt!-3Z=YA}zy zyO|4UjG?6)fJYH{#-uglc^+UyfAWX#ZMK*eqfA#IT#Il!!b1pK5q2W%L--@YQH0p* z4M#_WJ_x5HOhlNCuo&SAgliFQM|cQfE5c5MeF%R-GFu))LK{mv~|SOkA4(4gU&+P{G0w0|t+KP0EFfUsRc^)h^L z)}UdeM&uvX&X45(XNCVW4JfSQ-<2XwHv```jl1)*mKOie3lRMSeli^Tq#Ln#q(Y(6H^7A`2IYsY&INiPLdxOW~DbiXgJC(;dmoA5XrFh5nmnX@;W1*Ek?j^&4*>UKj`2SjD zrEjT6`FK8WepGtO4ayKzIA0}-ZLBATz|VxpT(v0O-7u&% zD=Rn0;OS5=jN=T8AJh|yz~)E`d<;X&WJ!rhhDr)FXG?iN%$lZ9MJ0SCwf1C)#ze$G zj-m)F%-5~hG&br>pv6?=V$Rg~>T2G0+@h-bqHrIA@eR0Qk;GqG>)L+mUBPET|57hXC{yV-&&@)s^e z95WeAJ!~3#x(AKwGn74YeoL!pb5PJoBwlLn#qy%!{DS4$^R3d%D$YR(!joc=vONkF zDI*v< z&X@PE4&y2c3i7qBfTx>8lI@`|fxxlM)g(|E4FM(!!JPMrf8n6C7jt`($Wlz~sf=?u zaOTP_0{hD-O3T6@wW77~eb8gVa;4rENGEEAd?Z9?w$Jw>s7#a{eM;D@wmlpOQ$Y*$ zfJGy{aIkbM;Zc@Y3WQpID)>>r5y>;9Ybn)~tB#lMBN&l*YZx}W?o{-Ss1>b&z99@I z!KZ)~f!TrU&`l!qID*z`7DFm~dG!Om*2DT_R0&O!8W*q-d!aIDJ_PIr}aCt6P&-fn)>rtJNG+A0K>chfdyQVlx zt7?TArv0rIX1L}Q=7rUrM3^%i6O|MOg!cWQ9=7tgG za$9@rB$WEc6~m!_t5vo96N>zk@nSX^ktN$!tMGkchKfQT{!_%2C0a3x*=ltjgK|cq zq?mt^VsctmjAAZ=s#g>&@|I$9;nnUBLuI99rZt37R%<>HMycBF19hfbQsf_1 z1b~S`G)It>;a_Bk>`S1sNfpBF0?v{pMraNb37m>TSp>2@v;hcHiomHTmI=%M!eFWW zQfS8H9g~`VFQS|`d9i3gfBd1ZE{Az-S`Jh&^cARB{WeTS_>w;^r?RkQdJIXngZ$d3iY{g`lm%c2mN`aQ zE=E}{#)zZIVwA~ZOp_^F#hA7#K@Kq^3n`XA9f_&t9Le@R@{U>0(Z_DY#Ts$OeN0o< zv^9anxQKP)SO`U3_F0D!ck<4UJzLn*HRl)Povk3lIR-5DIV7{CJG40C5yq}0axQaq zTngS>V+U=+BYqsvamo4_LafE_!ZWUezEMCUelSxznxG^86L7?JGC^1TozN#P)dZ8{ z|3c!HPO9w)9EyquK&IUGFI10G4gE0~r9beC<2=qt~GyRygd|8sOr0CqM& z_*VW`4roFPrs=tvGwVC_W>|l?9B?$x?*}}(}GAh zy)Jh?=ykbCm5+_6cM-Q41E6ROy{=)7D9Y=`9wdGr2OW$yY&(W>z=m?bK+*w&X(1oV z0b?_rgBAV<5cy*1fQ^wAjM5bv)ogk2>U8I^^uxybHHgN+4<}-PHEv^i?AIukaR;Lg z!-oGjg2rX~(Cfh>KGYuVL+u^(9U!x%D<5j_XoAXz+B=z`@}c%r6I4Fb-q{3|54CqO zLFGg3T}@E=PR6f*xz6mNHYM-jJmD|#l54A`8Q2TWKbII5Aq4uYp;zR8(&O$Q)Z$enwhw(lI*~SmvJx5n43QLC0B$^%Zan^C&a0f_#uF~gL?K;tLkTl1 z<>~bjW}3akMK_)>i)2dqaxllzjVEOPm2wIxz?IEqu_MRf+M&0HqHBY^V|$YZ&nXmb&x z&fjBZk=!QdXXLb#c7CGJYOX>;x%mP)q~vWDC>>o|JDoA6wNHmE`GRmtiQNl{ZSqnP zb^aP(j-(m);NjYf+>&NmYH_8MG)qB-7W)7wlCpi|c^6-)$%XMCa9xS7rRIT&qY~I#nQ-YYWrL6lJoj6gekfuAmfXnM^9dAZN?1f z0G}h@LTRv&Hsd~g$KHXjb|p^nPwx zV!L6|auadga9c^!Z)UW6cc^#_i7`6>b!|(&5?$vpL)sT8r@pi|@Hil!h}`vOWx8uk z1nxu6uXe)nlH1lZK=%irdPhaj7P zzK>1dNrGJN>+k0RJOHpa4e17{{_Y&I14UEXr*=prf(iEGT8I&yOPhBi836;}{jSKL0J{m~+c| zSoHt$`kX6ZYi^14d4hod9qaS9B001^=W^MW{y)Dy?<@J9v_7X9%=Njlh_yaf203|s z&i;Z02->|Yx>y|PJjAk12=)vM8?inwWlm~+em$ZXt=0OxMt~n!pRYw?+t3%XQ0sHb zlJz+k(XH0!%-dR@b2{)N*5@Qsjh#zen_8bgN;xvIi_ac_Uhm|@F5cY6(wv;w#m`~S z!uaas#4dg=$&?(~XW_&y{-UoaM<#X&GuBX!Of+XIPR+@QUBWC&4kvaA*(8G;Cnt6Z zbFLG}g~Dec7H4c^o}Abv%pHsG_WE~V()a1~L(d@$fW%rPq=^52mr=DTP%YH$;H33+ zdMzlA+-5lDfciWL=pfYBk-8G74l=Y{$CNJ#%D{8obbyOM(eX8A>8GA|5u~E}^;Gml zf-;;1SSG%#t`8~XW`dnJ;p+w9x?HO14~QI|73dFg3H=!GTIc8R)d370`_rGlNSY%^=p01k zD5X74X?0Yoqwv;~m-92N>$Y1A$Eyfka`Q~qF1ZWM7(}E(1w*vYM8BeYfQEoQ-DmI3i`wQnfxm9drnLEc5ou5$hF#Rc! zJjuzeV&in3Tdf$1oZKolLR-a7ZWSA$tzsvK1tYXo>~s+fZ52DYRcwT|ik;jlHbPs) zPHq(&7nnL1IyqPv)AikwZ?P87tzyI6DmGrA84|e7VZ5j;q9wGjRNIt6j0A3T7`1Bq zo4trX$X4?c8FW~j&``uSAy{sk3AQh2KLpT54lQCY^1voZM(jN9{v~T@;#%?s`VCDc zO|c8u3LUa&j+;FKGznZZ$IVeY=vo37&2e*?z(sSMA>$<%&2bk=^kcO;jEQx$UBBj{4ijK>h zji^Ib(T*7h5l`SM+A-78ldEXQECpe4&sDS|`zi9sD%x2%8RQ9EMLUZar9$+;&P$mw z%9g-Yw6lcgp%{}AxQcd`UN4X^<2^u&q2gz&+_VHW9xKR5P~$PlP8yFn zU|Hiat2aT7$Cey59$RwMcuX>uU5&?s1>$(TAEKhh<4-7CR{E|BS*v1K*NjNJx@MZP zHQNGExMrPAaa`#q&RB_W2Uq%z#2LRtJfRm>Q2Ii)P*%(PY@Um%RJFia0-ZSXN%C+r zz@0dA26BybNRG5;M^jy*vdT47=hF{qXztOMuo&l8E4S^ zaR#ku;~qp}35^qHG{`rNmZFbi87pi$$F=x7496J2ZiEi9QZBb00PPaM9WkSbmjpP^TqzDG8Gb#8xfsl$bLX9a+9Nr)m~lhv(T_~k(o6XtB%2U^3set;&Mn~7Z=n0( zJhJC3mVUXA>b&;Y3qOO=^kuB{ZuAxURcv7Ci*SfU^|cIr3x$87^S?`1Vg7I!;9p!Y z&efdW9HDRO1ev{)aeYN^CQpp7d1W`T&R=Pr-fTMhS8O^lzOPpHX4}!fX8B`$$5-}d zDutb#L;X&;%%+H`jDY{E~m zurXr2D+x;l8Unuum~A0epl=9a${8onM(iE*{W;6&5V(&_HJuWF4QYLN7f+8D_zS}K zGoJ*3lM(m&GRa_l8eO1vZq|y2nBCGY(iM6RO(&@HWAZb7mHp}vL58cmAh22+! ztgqxyB!}I7rPW=g)6z6Vu_$#f82eOG&{An4O@w7qjngeinu6KoKsKul5T{q^gN7pB zeG7oWV-Vv%`5inFkv)ircDs-?oOJ{+_3U+HwNZQ20lsHOi}lsFS` z-;ShzOyIt+GXA*4`!z%0FJQX9chlsl(y{xcqRCFCeWg%+Z7ftVrAUGM+1R>8?V%vl zGi^htHt!d9pA3Yk{yZR2{R>3!$-L}tT;4`dhH{HcC9h{#-U7<&rQ{``KXm8BPUK|* z5_vg@@YB5pNqs7*^{Zm_n~>1w95#s8rABH2_Z1)ihS*+J=vz{uO-PdpZ3tE9a}<|J zar;DEKWtd`xs33B5qBZrz9VS4_r-GEgJk%W1fK~*DH&cS929s1V1D|sq8nLfFO&N$ zG4bn^#_>U)ET!+mD`)!o5^ouo>nuGCgJjEVQ*i^XYk2O`9>O$e4_wqW~e<^qXZZGUfp#JvV} zs;Cx7a;g|wAjzrX-&r83Q^mNPtI==eR57$3l2gUF+?$YqS*n~W#>p18S`RT>rnP$n z5&1$fD8*b4akx^aZH^0HLtIYV95Wb2gO?LRhq?R4b=%v(#~F7pmGg1OEUvZM>knf* z#DKvb{R@PBa53>1Xi}af{xL??p4xk$?x1(V$f4t3i~`sM>bDSVn9T5iLvd_0IZ|YT zw2{WP-DIS2NvUs?#o0{`PA%?X=^&8*+Di|Jzy=6wK^P2yPlg0uA0_bmD1p~U2$XF% z2rQz&~vL-?Im9g_Yxc-_cLk%lpEH;Uzy{RL;l{(?G`iI>|G_E{W}5_o$ebZIi- z3$TSQO(v*IlO$8?*+-CSUYgvCXuNqSa}Xk2<3JU@H0j!f^zfxg7k9$KmnL1@2@7AE zba5vvd}-1ZeQDAaeQDAaeQDAaeQDCgov`qwNmulxNmulxNtbzPlG{h{@GkSxq+7rd zuINjXuINjXE>4)jmnL1&mnL1@2@7AEbbUf=4Ac9F2hU?u!En;+q3%?HqWO0%#56?Cs*r^t_FD^e`fzG1;MrY$> z|1s_}9AnV|uLVupFPOH4(L$iwp@VK=2mKX0Xq?d&xg_gn(+}XmPYLtpd=d+ zk~`tl2XMDse2oRr{W3)K89jJ&X9?gQJh;D#5uUMEBci$WHB@Jzu5W^bmk~Ar&7TY^ zo8*aBuLIXpbXX)h=relKNn(Y{%Fr+DbtO*hReU-`-b|6Rb-fniQXViI$H2avBKaSQ z^lTBCo(edYb)w(`!0D{Yu^4QyJm9~u#s0-bq}ZpsA!RbcFF~~#l6s5D-etq#WFSN5 z4}A3d^y#1}M|cNxJa^(Rlma|_j7<#t$KviVlm+UY+BDjxPH1m;0eS#@lv4Kqz1A{Npo5SQfW>%BZ80k zJJz9i!31p(^BT;#MeI%Vp}IbpbBoxU6`<__j}15YLURlLrkZn$M(8>Nzwus#*^Z3s zwu^>>*7`MtTFM#vl`P^+y*HA`(H&V#?Fb!K&J(-4iYq|L+4! z#b2%8j9;cd$5I^x>%aNN%750W|5>MEX7RsrooZ`+kY_Dic?5ULg{ygxcglsU9OONM z9%n6FTOH)7>#*t|Pp-p;4)R<-c#zlrLwE|qxrj5UWd5_enB@D>v1818vd%&-LuD20 zEMnAJ1v@XL>&D59i$2L&vO?0-Jy~bz{Q{|bvd%I^sqV=-FINyx_?Cbw@`R5vtfDPN zysdb0zK)??=nD+@0Fk0j_$m=KPxx2>XEs!KIIlQ}xJyUed8Nt?(;u(qTqc{*={U%2 zMnRp+p9Wb+JqdnIzr-f{-t=vcAS{PBJRjxi^c4N*JR9Q=0@q1SGv?XuMA;hvbFPzP zV;-FcP|SSWg`n)>K-PM$jXGlQ8!A77oZ<|^9ra^O9F8mEfVLp7qX^$Y*7M-(D)|kQ z{4gu%D%lN_?6BfzZX+UcJ1ru&(?hv+)Y~$LZZT@T{!7DgBSPOaP2;s-Rid;QmS`q$ zszhlqEKvpEG+BOkk71c^0n9vm2$Uup{O%am+CxZDCGHs`C3ds)y<${}^V4L@zJCmh zxC5l!I4kOn0R^)n{&#U$p)DCEDy!E(zxNS72I=;Yjvlc>8~k!p>F5zNi~>xZCPmm` za)ceGMA+dQ+M%bibR*>Vc^J1#!Jm%ViL$gi+S2YwOZSS%Aw438jEEfCGlvr@hoO-E zTZ9_q!1pXDOMfRhYzvj*JIUf8U}fpQNiHV&VK{}qCoo@!Z;-HoJ;9+o9I*w zoYLtw(djFTa{_=U`_G`m26=4$O+!o5|ImxL4xL(XY1q7oJ^cVE>Zh&t=LV8<79zrC;O6|>8 zRz435HR?l+0?=qDkV>QLBQ&}`q|ptQMh}1x2YLE*WV8|Cbx7(9DXQ#`ibltQ>qRy5 zL2x}adR$L`0&r?NG`b&=0f=N+sl8tW<}6_F=`)NPrRt)D&i9ol+jNrr-MsLkchWf? z(oUTP+gU8xMOgZF7Pp$Nv$M0ZZ=$?HUG&-nRW?70mtY~U!RRub>X^7lgscFrldK2w zbq<`*5SHu;B)fMB^M;MSSm=9a0OlPVeTl#xz+GgxDU!TwzOsI_OLGiJ%JfVR;+doH z)!zZ8-WMXa0xSdO5jB#iLc|^dil2ca0O&`R75ILZLDE9LJ_~7sM60i9gTb)DG2(`Z z368TZnHJDP7Py6?&QccGg3|xyF&xApAHL#6SzwfuAhtJPvA}4tz*&SPuQ6hQ`Gmy+ zV}<^4!eW6l1%4B-vcTCP3((5bp_D#R&pZ$D%(L;;zYv(-*@(sVfd%Fh#R*C8OA#9a z6hA}tx2g9&nMc$@<^0F7@`Uf(J@s$k|H+X>K_7`C4zXb%tr7ay|Q?mIMWDJJ}lM#l<+@z5M zH9nY!AbqI5jG3xqhcXcT1)*nOP2Py3)ZIvRrvatZ-AHwp0aWVBVZ#Q3qVBy^cPqf* zQnQ<6uIO7JDsMJb?!OBe4-p+7P|f``J%FyH*vsCscr zhKha-lv4B>D(cR(6kSWr#t{@FR}q{KP#O8!NF!fo8QB2|%E;GSMy{rjFV)MCJ6G=4 zK>}a4sf=6{W#l5u$a1d7nS`9{CF2F0hzpVvIYGA5QaT`hM&z-}8QdDN-)tVcJj9l$ zc~M&P*rg0T<|YKb+O7hxuX_b`{l8%o;Z(PQ&w!O|cmu^QJj18l|CetAs}hB711m6e z8+eVBH*_0#s(_)}z!wYnZ@&$!bp99J23ErUE4P8wo!QtKHjI{XXErwK&TMS-o!QuI z-hXSOUxb#Aa}zfHClQ`PKO7GMN#dWkFbZdvypmK;(%WEPFV0{VZS;dgKB(7%Z8yS) zVC7+fVtv451>M`EyHjrf&HD%m{c%?+ME8p@-67K5s5gS93E>RT)rRQSTXb#pMWnl0 zC!!g2?a^l!f!2B-)K20Sg9RDwq)02s#*4ZXQYb>)5HJDZMhH1CBxFgH z5EC+m6q!N_C}frhnGON;9xp=3jUgeb1}sfX$P|(-LfR`&rEcQ1SDwnemcx00O}h&2 z%+PzoCF>pV6-1VN$>zEzad#3<>_47LoIu)t|L+$5zD(8bOfh$u!j{)8@e?l1w=Pv~M>zv8A365EEp;Ei}LgJWEvZ z*`%tb7Muxo(B~1Z)EmI@KEm1H;_GWv9@kiTbkHv$-7>uqG))MXfsQXQRCHHbbnW$X zNVh~Mq8W4}(ev*B?GVs*6uk?XgaVEyVYU#C0})+B9SG-!2xkjnr%0F6Daz$E;6&J_ z@&2JXIjX~Ch?66}xAzRZoA*w5qyG&q=RYSb|2bhnH~pz6EWG~rHJrhzejmk!jCK8w zZ-qJK^*<)S1tM#1B->8lEAAqRs$&(dc;bv9__mH!u0h;9Rv{Wb&b$vOSM+}1J|NTN z*ugq`pcL~y;Q5HQAB=v9+iJRA2PmZrq1kc|T5EqFfvHFmrz1({n@O9Pgj)&vHzBS( zmDJ(aOe&O32=?{65dLgA8Jx2(c?8z!IuN@RIBFMwzAjZ?OP5ojZvy#a2%|w!0C&?_ z*2?9K!k>1&mcq*~6Nt7OjqKx$yYZc>UqcBi^)29j31KlL{4ykAMU;dUmV_?)+vM`= ztjk((y^C-&I6n$;u8ZPa7v_A6oVN;RBe=dscp031utZf_-x9@ni^~Y@cO0Ue=``;~-@wLN=24_So)X@RxMOOzLMy{i>o~0Llu4HK68;Wfk@A z25 zo&{V_*^}xjTlE!ydx@xSHg?oH!jesQfj(038^?zRl>-epwatM^b?wod@D zK6l_tDq&Fmo3f$Jrj4Hw!60Hao#S&)v3eF0b> zN7#=fzMEIEcMx{I1WmDb684FJ(F#X1_iqKW1)Sd_T!oY%xcf@x-!SiofJ&3RzoSut zqQZNP!jm|;7qafr(8C56(j$V zHbyD$WhvL&q@`-l;D3!Eq-Eifr_-vgYRPsoaH_hhCF|<}tLnK?vU~-wQlUoRUXM}m zO%fk844YsqxC_EhL(p%r9f49A{ApRnw@Bzcnbp@0V4v>z!lo&U%^s`YZOh=@n%>Ju zF-a1k_7#*q%xq z^-&0Ym#U7iMW|WRN=;}|NKFna113X@tq3b2h1au`CZCHYzXDEa^0{cz7|QvGpB*3+cT@^xgrS(tC^O{Vian_miUMu+uHQpAz^wz@qon5c(h$dB(=Gl?c7} zx7M5E`+kr%lKdsxuSw1;{z~ubmEPx4?|!#Z?YC8j?C0@&2dHxu@T%EOlH%D$TE&|r#XA?UD&7<+!qtFP@y?4V-uV*$3~8zfB7?74 zylFPB=OT(XlFCOk!2vWcUpRsvbY(n>c<(||Jc}4U?RQXXKjvnSBcf(>>!h%Q-27=i zP8eCd!Gi|%xeWw^$uoo{T7c4xegSXX9EF#FB;gc=zc?HYAZs~N1|ek_8Onj_Px`BY z?G3DcgT5E!8Fj#Atu>J%dpOBfQ_&mrZ6T7ILDCI;VUi7sWOImQBS_jsk!(>U*M>+Q z0!dsH$u325S%_o{NKPPxGip>M(?cXLAo(v*B*zuWX(5swNdBWmA_cDpbN~UR>JlP* z%|uFO>2z-ISY*}uP&&3M7!DsvBRhrShs7h9h673~iD;@6PAayNh-QJpNrhGt(KJUm zDc?#Wn#K$#EwGY^W>tifF0qn`mfEe>m0LD7Cys3aEEfJWeFl5f7F{2Qgews?pr{Lz ztxocUOe}T)*Gn4UZ=?bK8E`rq$P6$nro<<8)rMx9h_ET=TO{F3we~x~i=Wc!`Wob< z+Ig|rw9%-CF#pxyyZA-?o z52fc`ih{s~Od@?Oi&CbKV3M>aNg=jvR0^7tq!61Hm4enJDa7`TN-(r7SR0 zh&?kZ1x-nKh!r!NYOfBfP4qOyq{brcH2vpnOO6lmy+PMEf#5xazaimIA<=h8GtC@hihdFVI}xza z7Z&}pg)~La0yRGEZ>Qv+qb(-3x7y-W5p9u~G=lYoZH8kBSopJzp(lX61wenMo0VN?}`M3bA)brLZkB<^QqwCh%1ici;HAITt)YfP^56B8JtC zYy@RXAYqf8kg#g?5|Wz`$VTqHELH`AYt_niZ)*jYr_~CIOREKIQM-U$L~X_HSfPvc zX;r#tZ6Dw7_ct@=%)KP(^7y>(`~QF51C!r6Gr#%Ga^}oAcZOVXvo`y9U^dx%R3tT@ zLxZ`D)jGfp9RUBo5Z;G64+~Lk@l9i=d6`{LrOL z`T=}QgtbtvhpvX;GC%42r7eEiB;5}RqY?0uEJ%8&Vd|v6s*;x1*qqMEYwTXm1x!_# zoSOq2Im}uh>)uV<`5Nu40!P^? z89(L$?L zJ&#YLAS5mR`6=_g7#x+akV%k|?@{Lab1UEXO}^iTisbttkkhiTI3)RwEO+E`z3_*~ zczB4LsDzG5_FIwl3oqaX0v#S4CE35p>}$YL*$ep@kdpn`NH%ob%D#;Gu-Gp_MY4CN zA$#t8EZL6%#cOzIA>I8u$@ehw9Q;kZk%W-PQ%SyWG2eCIsCE965Uv+=g!#7v}- zjW-Q~j9|q-O-oK>Ahuy1-Jr@Ss5D!10i0RPtd0t(GrD~~CC_WM}vf=Hk7 zgbg6&I4AWJyOWNAS_nH+&woli_zA~tbPMYRHdi` zo$jAuf@^3~-!T~*ax;u=8;xxt%>FVq8QU&o2AgXoUoZ2Aq%KobR%QmNPbz9q=0;MN zH;ZO&=61U73YE&p%zDbMRMgqdDTNvFxyV>qzvYW8h*-Z>xMKabOOTMNC~kKy))zS4 z<=dWiTHT$S2W8yIG_yjNgOSawQAynDq+i&*_)fqa*^nVeZOG7FHV0cpxAfYF$Xml( z`Jybd6vlXJE1S^S=u88yA@O^nu$B1_3=M|ILzSY<9IttEdhp=o5?n}@*O;YVGIeY@V(`1je-jXEm?%ZUquTW2d8uB)> z4P^<9Th{o3rG@(GolZj1LZ>q4}inNFGddmlV7Tw72+yH=qKWk5VunqAesGG@)c+Ol(wAR z&7J)t%r!a7 zlJav*`BJdPpm;BkSPvqPR(=u6Pa=d4=5J;~PQjmPTqG2lf#?Hdcf3p4c!w*0Du*y> z=R0`$g>V&;Y6Lwp4}bQ87&QUNVIcUz`ZIL%Wud*$n~Sma_u%pazalYfGZQ-vLn6)k zBnh4@I+n#f$dSLD`xxeb8)WfO(5j@)IMznicd=_ULg=dZsKfo&&Nn=%kgJf=Ijj(T zpUk%$ZOAp$&Ao&UEet(Kvv!9nU=oM?Jy2dvv;ImaKFkjLBe063^bfQ2AAnRI*h@Rd zivzI89eON(B@8GY1pFM98h~3R?1fzGD+7mMwaq(jkaVz!y&WM$7iryO0+ep0=j9$gU zbaPv&mmp&ai_^`GlQEPjEgfI{EKvn9iSU^PuhbN?C&}zd(s5oW6Pd2!LDPn zCrz;HnCwXt>^dfU(geGX$(}U9u4A$%O|a{j>`4>sIwpJ41iOyOo;1O(W3neru^dfU(uDn8$7D~MVAnC(lP1`8O!lO~u46xx zl+~Uz*mdl^k;4$ye`56MnLn>`4>eM>q6QyE7|~IDORa%*r9*KIvaM-hv3HgujEP(Dy$4VR5qV z1VS#`gm6DJ+_Ri)d~1}24%km_&Hb#slDf<8U%mJfp3GC0awDNWvPrVpi@(oz!8&C* zp1x2~;Xb@4oU(#yYOkcvlK)+d52vg=9n752Q4R<9%U2WZR=+?PJO`_05cVIC1KE8< zXM)8oSMFoFQ4p}3n+)cJ@)%!zb#WAN|Bi4KoVj|8<*k=~u zB}n)s)BwrsLn`y$G%&P}37--QWkG2u!iP}gIj)05v3tm9=7dV9xn3AJgvQ&5aMoPM zxdF=kms2Lc*scO=u*7X+)EG(nDiotRUj%ttAqLOWxig5cPLJRrA~v43!t_!mv|KXT ziVTh*d=qi_+ZmOKRKUA_CM%dp_B@k`?CLcW@1qko*DL z0t@szQcp-;t%&&n!k?ja(9i2}<~4l2$xFWA$EwDVy;_@jeVK``fR4)RDV2UVVF?%?>QD|yNl_xiJAEjrg{EtFCf}7Dg#2?R-Ddz?K8OJuIk12Y5)3>zs(=Vk-wqr(5OB+z1%*h z_sK>vvrwxUBb{EorhtWcn?^m@s!&WD#yM`ENxdfbnv*j%GovRSd`3HSFxWVuY$vPx z((bNzx;M(pL7M~TAjv+GQa6)QUqtm(kr*}W)X-U(Dn@oUDO*2@ zh$7{LQ%vZO9cTLt>5Tz9KQuK{x#g@(IoFKz9R9y@W;!e#h$?T*mj9*<9$y5PqLstQ7qr34VYv2@9 zHJ+-P9;r3bMHQshRc})xeN2t?9StM1QmZ99wOaZG)q>VVbNZWVIW-5)VL1n+*3Upw zKZEkMtIx{JMg0%<{nw2(oh$9>G+jGrKyY_HDw<7#5m=Q&g1W<6SWs0MfRUhcrk^5W z*foNu2D_4nStM$8cu-MnAR{aiO<-g|;t}hNP*Kj(?kjq&6npR?Y*7y5oJ9mrj=e%l z5#^k5WCJ;u2p$F*i|xb28*>KuDj7Tu+EP4IF%1^BfEk;{Rv1{J8dH(Ypb7tf?C5rV z2K}plYW1CJk?{F|z%i_XfdQ#HyVbh~8&|WNYd%_CFASOe@YpqkQB4J$VcTN2t)Z&p zo*CrRMQ^wJu^HF@djqc?X?vQKG3cgt^9}~y(P%Aw!=Ydl&oW&!JLum1RQJwN#p~}E zADuO*3gdfNL1)wV^rI#R`jOK5W#sI%TjI@gplzmi?JNw^gP3p3r6_9#dpvC8y zwuOhZ|gHG=?rj2lH{a0Hb+swy! zr}<}FU&pRb9|3GFyVgy6l$p!Fd*lBf>dv+YdYJy#Gxc7c-j#LF)_uOWsZY$M%)Pv? zxtC{k<`c}OOs8R&MK||52FM&gn%tCw)^1#`oA;?!lSMQ$=$ekN`Xc96dN}x}Zud}U zcSa%@eDn1^Q%&N|FwGvbDs{`nfU9n@xwgrH!NY>o*r|Av*S3(9o4n~gopo@_Q&tB@ zW1{0s2bZ>m8$WZFTfcE9ZvS>iK2LSzF=|SXr-oH@Yf~BjMlOE=T}|d_(sMSct-W+)Msceqv$CyJ1Iv*L!to= zvfUnZ!}OWGtz|b;Sy(aSgc&7SQ^+ZJ@=6<&hw3h&2UlyvG^+`@x;E9AX{jSw^VHAS zAV;JQog>xIH%bkCnA>yc!&AN)=NRQ|+fmAq7%`28zWvh|cT{O2SYUzA19iqieN-cxi?&(?s)%S9SN0xIST4l zhm|VZ+1YTXFX@-+M66UPm!X{lfsZhKRY-8hmwS@RWneFPyu@9ex>yoau}@Qt0jpBM zJSk}ET$?f-f~__%j%~%<-F2JhYJpKk7P)>^q6uJiij8f!osHdBq@@OHP*|U$I$A1i z37$idQx}7lzNK}xysTChQaVItYvmUMmK{M=8;318&k!jKl0n5< zOOmWfvmBwv4KrBjLC7pgXz5VD61xQnnx!J>uBDm^l}Ol<^W~dD9H3>O4Uj+T$!7N@_EW6FGxFm ziWf9^)^xGzS>voRSk_n1H;wuNnr3Fop2=@b|=jp^()OinEau^8xKpfHytO-bewFvt@kr+J$NWjn>d^MwjNcu8fVp*)%-b* z1*>r>_XV>SryDR|fLM*djCny@z@xdT6>A0FjB);QT*_K}&<;`_*6mTvtjX(+W8Izg z!+P-8WLD(0#nw8UKj5Xm1RH@`%5cuW-%#j7)B=9SgrU+w2ssVS4e|UMQ21O7A;VdS zzbC2vt1kx~r=~65fVYFp$LW@ldp&*?-zPMzU|8uz!|Lk`3NpGO69~q<3c=Z005^t0 zBM~LTIntpOiC9}fW5eo#`kI=8hH(=v$ZKq9PHf7nZ%!19%O9IxT+q;5)0n7@ItA3! zM8WEYc+APqXUr4<4rPfpM^)it@!HyGUH%#x9N*j;jRD1rQ-k8oGg4`)ZUq}Sv>RH0 z;yp1EHE3IPb8SnL(vXzbu<*@^n#O2LyrDJj^2P$-x&(UOZV(4UG7HOceuSu z=4~jLQt!n!xf|LuM&`Ix8O5PrU$o!NoLlTR?$+4owitBg;ShPVf4ya7pw`;1rNKHsareg6Ru{I?-m z6K`olL~vu#`le`eoRx#Cu^|>${MPCQt+A#$wkBS^x{)~{f^;Zn`@#}#8n@S zx3n@kEMp5TyNUZYghF14d&vs7<({2x@jdRs6+7L2_jo(8jp3(4-U=+De0Zg|&l~x5 zuQadT+upXwJ@w%J7gyHTPIoU`G3~0Ad8PG#+>=*Oe|*hx{PhYvaMtYihT-4N@9aP1 zUEmdY1^YAdbH2OMtM|$edC%@Yv}gPFJ^Np}*p0sCO+kzW?!_4+Lm4CcW{m8eF|v<) z?-r2Wy!~FO`nP}o{)|ji`Gc@K!#NJyJFfo!UX9!R$8x)j6Mm($PCwSJ;#W1hSV~p1 zhFWhy4gHXv#@i{~=8-K2cet5#+qXY5-Q8SLT3;}^bjsB8re3}O(BzfL?cO18o_krl z+pFEp^x|%heeT8*w?~QoyQ$>Jp+C4e?QXoiaLT0ZlMCj1^Nw%d??yAu4xLDN1;@9a zaN`*TtO&P7DkM8&WPf)oPyc-U zyYGcV?Nj&cIUX(DcJZDkOQY_+m+#izoRFVzXT4XRk>7vJ6n8_u+jqCSeudk&Q%SrzKK&OPQ3~Yx5o}t?UedNq7?sF%e~sYg1pkT?$cYm zy3!M8y0Lvz&UAm_?E9LVxngqZWH(Xb_N<$-c6`HxX_F>2l$|$uZGHWA_ly

U?)- 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 QOb7j~sm)zE5$J{d0g;uQQ~&?~ literal 0 HcmV?d00001 diff --git a/Robust/src/Benchmarks/SingleTM/genome/genome.c b/Robust/src/Benchmarks/SingleTM/genome/genome.c new file mode 100644 index 00000000..8a1ca271 --- /dev/null +++ b/Robust/src/Benchmarks/SingleTM/genome/genome.c @@ -0,0 +1,285 @@ +/* ============================================================================= + * + * genome.c + * + * ============================================================================= + * + * Copyright (C) Stanford University, 2006. All Rights Reserved. + * Author: Chi Cao Minh + * + * ============================================================================= + * + * For the license of bayes/sort.h and bayes/sort.c, please see the header + * of the files. + * + * ------------------------------------------------------------------------ + * + * For the license of kmeans, please see kmeans/LICENSE.kmeans + * + * ------------------------------------------------------------------------ + * + * For the license of ssca2, please see ssca2/COPYRIGHT + * + * ------------------------------------------------------------------------ + * + * For the license of lib/mt19937ar.c and lib/mt19937ar.h, please see the + * header of the files. + * + * ------------------------------------------------------------------------ + * + * For the license of lib/rbtree.h and lib/rbtree.c, please see + * lib/LEGALNOTICE.rbtree and lib/LICENSE.rbtree + * + * ------------------------------------------------------------------------ + * + * Unless otherwise noted, the following license applies to STAMP files: + * + * Copyright (c) 2007, Stanford University + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * * Neither the name of Stanford University nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY STANFORD UNIVERSITY ``AS IS'' AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL STANFORD UNIVERSITY BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF + * THE POSSIBILITY OF SUCH DAMAGE. + * + * ============================================================================= + */ + + +#include +#include +#include +#include +#include +#include "gene.h" +#include "random.h" +#include "segments.h" +#include "sequencer.h" +#include "thread.h" +#include "timer.h" +#include "tm.h" +#include "vector.h" + + +enum param_types { + PARAM_GENE = (unsigned char)'g', + PARAM_NUMBER = (unsigned char)'n', + PARAM_SEGMENT = (unsigned char)'s', + PARAM_THREAD = (unsigned char)'t', +}; + + +#define PARAM_DEFAULT_GENE (1L << 14) +#define PARAM_DEFAULT_NUMBER (1L << 22) +#define PARAM_DEFAULT_SEGMENT (1L << 6) +#define PARAM_DEFAULT_THREAD (1L) + + +long global_params[256]; /* 256 = ascii limit */ + + +/* ============================================================================= + * displayUsage + * ============================================================================= + */ +static void +displayUsage (const char* appName) +{ + printf("Usage: %s [options]\n", appName); + puts("\nOptions: (defaults)\n"); + printf(" g Length of [g]ene (%li)\n", PARAM_DEFAULT_GENE); + printf(" n Min [n]umber of segments (%li)\n", PARAM_DEFAULT_NUMBER); + printf(" s Length of [s]egment (%li)\n", PARAM_DEFAULT_SEGMENT); + printf(" t Number of [t]hreads (%li)\n", PARAM_DEFAULT_THREAD); + puts(""); + puts("The actual number of segments created may be greater than -n"); + puts("in order to completely cover the gene."); + exit(1); +} + + +/* ============================================================================= + * setDefaultParams + * ============================================================================= + */ +static void +setDefaultParams( void ) +{ + global_params[PARAM_GENE] = PARAM_DEFAULT_GENE; + global_params[PARAM_NUMBER] = PARAM_DEFAULT_NUMBER; + global_params[PARAM_SEGMENT] = PARAM_DEFAULT_SEGMENT; + global_params[PARAM_THREAD] = PARAM_DEFAULT_THREAD; +} + + +/* ============================================================================= + * parseArgs + * ============================================================================= + */ +static void +parseArgs (long argc, char* const argv[]) +{ + long i; + long opt; + + opterr = 0; + + setDefaultParams(); + + while ((opt = getopt(argc, argv, "g:n:s:t:")) != -1) { + switch (opt) { + case 'g': + case 'n': + case 's': + case 't': + global_params[(unsigned char)opt] = atol(optarg); + break; + case '?': + default: + opterr++; + break; + } + } + + for (i = optind; i < argc; i++) { + fprintf(stderr, "Non-option argument: %s\n", argv[i]); + opterr++; + } + + if (opterr) { + displayUsage(argv[0]); + } +} + + +/* ============================================================================= + * main + * ============================================================================= + */ +MAIN (argc,argv) +{ + TIMER_T start; + TIMER_T stop; + + GOTO_REAL(); + + /* Initialization */ + parseArgs(argc, (char** const)argv); + SIM_GET_NUM_CPU(global_params[PARAM_THREAD]); + + printf("Creating gene and segments... "); + fflush(stdout); + + long geneLength = global_params[PARAM_GENE]; + long segmentLength = global_params[PARAM_SEGMENT]; + long minNumSegment = global_params[PARAM_NUMBER]; + long numThread = global_params[PARAM_THREAD]; + + TM_STARTUP(numThread); + P_MEMORY_STARTUP(numThread); + thread_startup(numThread); + + random_t* randomPtr = random_alloc(); + assert(randomPtr != NULL); + random_seed(randomPtr, 0); + + gene_t* genePtr = gene_alloc(geneLength); + assert( genePtr != NULL); + gene_create(genePtr, randomPtr); + char* gene = genePtr->contents; + + segments_t* segmentsPtr = segments_alloc(segmentLength, minNumSegment); + assert(segmentsPtr != NULL); + segments_create(segmentsPtr, genePtr, randomPtr); + sequencer_t* sequencerPtr = sequencer_alloc(geneLength, segmentLength, segmentsPtr); + assert(sequencerPtr != NULL); + + puts("done."); + printf("Gene length = %li\n", genePtr->length); + printf("Segment length = %li\n", segmentsPtr->length); + printf("Number segments = %li\n", vector_getSize(segmentsPtr->contentsPtr)); + fflush(stdout); + + /* Benchmark */ + printf("Sequencing gene... "); + fflush(stdout); + TIMER_READ(start); + GOTO_SIM(); +#ifdef OTM +#pragma omp parallel + { + sequencer_run(sequencerPtr); + } +#else + thread_start(sequencer_run, (void*)sequencerPtr); +#endif + GOTO_REAL(); + TIMER_READ(stop); + puts("done."); + printf("Time = %lf\n", TIMER_DIFF_SECONDS(start, stop)); + fflush(stdout); + + /* Check result */ + { + char* sequence = sequencerPtr->sequence; + int result = strcmp(gene, sequence); + printf("Sequence matches gene: %s\n", (result ? "no" : "yes")); + if (result) { + printf("gene = %s\n", gene); + printf("sequence = %s\n", sequence); + } + fflush(stdout); + assert(strlen(sequence) >= strlen(gene)); + } + + /* Clean up */ + printf("Deallocating memory... "); + fflush(stdout); + sequencer_free(sequencerPtr); + segments_free(segmentsPtr); + gene_free(genePtr); + random_free(randomPtr); + puts("done."); + fflush(stdout); + + TM_SHUTDOWN(); + P_MEMORY_SHUTDOWN(); + + GOTO_SIM(); + + thread_shutdown(); + + MAIN_RETURN(0); +} + + + +/* ============================================================================= + * + * End of genome.c + * + * ============================================================================= + */ diff --git a/Robust/src/Benchmarks/SingleTM/genome/genome.c~ b/Robust/src/Benchmarks/SingleTM/genome/genome.c~ new file mode 100644 index 00000000..8a1ca271 --- /dev/null +++ b/Robust/src/Benchmarks/SingleTM/genome/genome.c~ @@ -0,0 +1,285 @@ +/* ============================================================================= + * + * genome.c + * + * ============================================================================= + * + * Copyright (C) Stanford University, 2006. All Rights Reserved. + * Author: Chi Cao Minh + * + * ============================================================================= + * + * For the license of bayes/sort.h and bayes/sort.c, please see the header + * of the files. + * + * ------------------------------------------------------------------------ + * + * For the license of kmeans, please see kmeans/LICENSE.kmeans + * + * ------------------------------------------------------------------------ + * + * For the license of ssca2, please see ssca2/COPYRIGHT + * + * ------------------------------------------------------------------------ + * + * For the license of lib/mt19937ar.c and lib/mt19937ar.h, please see the + * header of the files. + * + * ------------------------------------------------------------------------ + * + * For the license of lib/rbtree.h and lib/rbtree.c, please see + * lib/LEGALNOTICE.rbtree and lib/LICENSE.rbtree + * + * ------------------------------------------------------------------------ + * + * Unless otherwise noted, the following license applies to STAMP files: + * + * Copyright (c) 2007, Stanford University + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * * Neither the name of Stanford University nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY STANFORD UNIVERSITY ``AS IS'' AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL STANFORD UNIVERSITY BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF + * THE POSSIBILITY OF SUCH DAMAGE. + * + * ============================================================================= + */ + + +#include +#include +#include +#include +#include +#include "gene.h" +#include "random.h" +#include "segments.h" +#include "sequencer.h" +#include "thread.h" +#include "timer.h" +#include "tm.h" +#include "vector.h" + + +enum param_types { + PARAM_GENE = (unsigned char)'g', + PARAM_NUMBER = (unsigned char)'n', + PARAM_SEGMENT = (unsigned char)'s', + PARAM_THREAD = (unsigned char)'t', +}; + + +#define PARAM_DEFAULT_GENE (1L << 14) +#define PARAM_DEFAULT_NUMBER (1L << 22) +#define PARAM_DEFAULT_SEGMENT (1L << 6) +#define PARAM_DEFAULT_THREAD (1L) + + +long global_params[256]; /* 256 = ascii limit */ + + +/* ============================================================================= + * displayUsage + * ============================================================================= + */ +static void +displayUsage (const char* appName) +{ + printf("Usage: %s [options]\n", appName); + puts("\nOptions: (defaults)\n"); + printf(" g Length of [g]ene (%li)\n", PARAM_DEFAULT_GENE); + printf(" n Min [n]umber of segments (%li)\n", PARAM_DEFAULT_NUMBER); + printf(" s Length of [s]egment (%li)\n", PARAM_DEFAULT_SEGMENT); + printf(" t Number of [t]hreads (%li)\n", PARAM_DEFAULT_THREAD); + puts(""); + puts("The actual number of segments created may be greater than -n"); + puts("in order to completely cover the gene."); + exit(1); +} + + +/* ============================================================================= + * setDefaultParams + * ============================================================================= + */ +static void +setDefaultParams( void ) +{ + global_params[PARAM_GENE] = PARAM_DEFAULT_GENE; + global_params[PARAM_NUMBER] = PARAM_DEFAULT_NUMBER; + global_params[PARAM_SEGMENT] = PARAM_DEFAULT_SEGMENT; + global_params[PARAM_THREAD] = PARAM_DEFAULT_THREAD; +} + + +/* ============================================================================= + * parseArgs + * ============================================================================= + */ +static void +parseArgs (long argc, char* const argv[]) +{ + long i; + long opt; + + opterr = 0; + + setDefaultParams(); + + while ((opt = getopt(argc, argv, "g:n:s:t:")) != -1) { + switch (opt) { + case 'g': + case 'n': + case 's': + case 't': + global_params[(unsigned char)opt] = atol(optarg); + break; + case '?': + default: + opterr++; + break; + } + } + + for (i = optind; i < argc; i++) { + fprintf(stderr, "Non-option argument: %s\n", argv[i]); + opterr++; + } + + if (opterr) { + displayUsage(argv[0]); + } +} + + +/* ============================================================================= + * main + * ============================================================================= + */ +MAIN (argc,argv) +{ + TIMER_T start; + TIMER_T stop; + + GOTO_REAL(); + + /* Initialization */ + parseArgs(argc, (char** const)argv); + SIM_GET_NUM_CPU(global_params[PARAM_THREAD]); + + printf("Creating gene and segments... "); + fflush(stdout); + + long geneLength = global_params[PARAM_GENE]; + long segmentLength = global_params[PARAM_SEGMENT]; + long minNumSegment = global_params[PARAM_NUMBER]; + long numThread = global_params[PARAM_THREAD]; + + TM_STARTUP(numThread); + P_MEMORY_STARTUP(numThread); + thread_startup(numThread); + + random_t* randomPtr = random_alloc(); + assert(randomPtr != NULL); + random_seed(randomPtr, 0); + + gene_t* genePtr = gene_alloc(geneLength); + assert( genePtr != NULL); + gene_create(genePtr, randomPtr); + char* gene = genePtr->contents; + + segments_t* segmentsPtr = segments_alloc(segmentLength, minNumSegment); + assert(segmentsPtr != NULL); + segments_create(segmentsPtr, genePtr, randomPtr); + sequencer_t* sequencerPtr = sequencer_alloc(geneLength, segmentLength, segmentsPtr); + assert(sequencerPtr != NULL); + + puts("done."); + printf("Gene length = %li\n", genePtr->length); + printf("Segment length = %li\n", segmentsPtr->length); + printf("Number segments = %li\n", vector_getSize(segmentsPtr->contentsPtr)); + fflush(stdout); + + /* Benchmark */ + printf("Sequencing gene... "); + fflush(stdout); + TIMER_READ(start); + GOTO_SIM(); +#ifdef OTM +#pragma omp parallel + { + sequencer_run(sequencerPtr); + } +#else + thread_start(sequencer_run, (void*)sequencerPtr); +#endif + GOTO_REAL(); + TIMER_READ(stop); + puts("done."); + printf("Time = %lf\n", TIMER_DIFF_SECONDS(start, stop)); + fflush(stdout); + + /* Check result */ + { + char* sequence = sequencerPtr->sequence; + int result = strcmp(gene, sequence); + printf("Sequence matches gene: %s\n", (result ? "no" : "yes")); + if (result) { + printf("gene = %s\n", gene); + printf("sequence = %s\n", sequence); + } + fflush(stdout); + assert(strlen(sequence) >= strlen(gene)); + } + + /* Clean up */ + printf("Deallocating memory... "); + fflush(stdout); + sequencer_free(sequencerPtr); + segments_free(segmentsPtr); + gene_free(genePtr); + random_free(randomPtr); + puts("done."); + fflush(stdout); + + TM_SHUTDOWN(); + P_MEMORY_SHUTDOWN(); + + GOTO_SIM(); + + thread_shutdown(); + + MAIN_RETURN(0); +} + + + +/* ============================================================================= + * + * End of genome.c + * + * ============================================================================= + */ diff --git a/Robust/src/Benchmarks/SingleTM/genome/genome.o b/Robust/src/Benchmarks/SingleTM/genome/genome.o new file mode 100644 index 0000000000000000000000000000000000000000..1566a82fa207d8f24c1e94330d155e1f20352d2a GIT binary patch literal 13356 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 literal 0 HcmV?d00001 diff --git a/Robust/src/Benchmarks/SingleTM/genome/java/Bitmap.java b/Robust/src/Benchmarks/SingleTM/genome/java/Bitmap.java new file mode 100644 index 00000000..0e437075 --- /dev/null +++ b/Robust/src/Benchmarks/SingleTM/genome/java/Bitmap.java @@ -0,0 +1,212 @@ +public class Bitmap { + public long numBit; + public long numWord; + public long bits[]; + + private static NUM_BIT_PER_BYTE = 8; + private static NUM_BIT_PER_WORD = (8) * NUM_BIT_PER_BYTE) + + + /* ============================================================================= + * bitmap_alloc + * -- Returns NULL on failure + * ============================================================================= + */ + Bitmap(long myNumBit) { + + numBit = myNumBit; + numWord = DIVIDE_AND_ROUND_UP(numBit, NUM_BIT_PER_WORD); + + bits = new long[numWord]; + + int i = 0; + for(i = 0; i < numWord; i++) { + bits[i] = 0; + } + } + + Bitmap(Bitmap myBitMap) { + numBit = myBitMap.numBit; + numWord = myBitMap.numWord; + bits = new long[numWord]; + int i = 0; + for(i = 0; i < numWord; i++) { + bits[i] = myBitMap.bits[i]; + } + } + + /* ============================================================================= + * Pbitmap_alloc + * -- Returns NULL on failure + * ============================================================================= + */ + //bitmap_t* Pbitmap_alloc (long numBit) { } + + + /* ============================================================================= + * bitmap_free + * ============================================================================= + */ + //void bitmap_free (bitmap_t* bitmapPtr); + + + /* ============================================================================= + * Pbitmap_free + * ============================================================================= + */ + //void Pbitmap_free (bitmap_t* bitmapPtr); + + + /* ============================================================================= + * bitmap_set + * -- Sets ith bit to 1 + * -- Returns TRUE on success, else FALSE + * ============================================================================= + */ + boolean set (long i) { + if ((i < 0) || (i >= numBit)) { + return FALSE; + } + + bits[i/NUM_BIT_PER_WORD] |= (1 << (i % NUM_BIT_PER_WORD)); + + return TRUE; + } + + + /* ============================================================================= + * bitmap_clear + * -- Clears ith bit to 0 + * -- Returns TRUE on success, else FALSE + * ============================================================================= + */ + boolean clear (long i) { + if ((i < 0) || (i >= numBit)) { + return FALSE; + } + + bits[i/NUM_BIT_PER_WORD] &= ~(1 << (i % NUM_BIT_PER_WORD)); + + return TRUE; + } + + + /* ============================================================================= + * bitmap_clearAll + * -- Clears all bit to 0 + * ============================================================================= + */ + void clearAll () { + int i = 0; + for(i = 0; i < numWord; i++) { + bits[i] = 0; + } + } + + + /* ============================================================================= + * bitmap_isSet + * -- Returns TRUE if ith bit is set, else FALSE + * ============================================================================= + */ + boolean isSet (long i) { + if ((i >= 0) && (i < numBit) && + (bits[i/NUM_BIT_PER_WORD] & (1 << (i % NUM_BIT_PER_WORD)))) { + return TRUE; + } + + return FALSE; + } + + + /* ============================================================================= + * bitmap_findClear + * -- Returns index of first clear bit + * -- If start index is negative, will start from beginning + * -- If all bits are set, returns -1 + * ============================================================================= + */ + long findClear (long startIndex) { + long i; + + for (i = MAX(startIndex, 0); i < numBit; i++) { + if (!(bits[i/NUM_BIT_PER_WORD] & (1 << (i % NUM_BIT_PER_WORD)))) { + return i; + } + } + + return -1; + } + + + /* ============================================================================= + * bitmap_findSet + * -- Returns index of first set bit + * -- If all bits are clear, returns -1 + * ============================================================================= + */ + long findSet (long startIndex) { + long i; + + for (i = MAX(startIndex, 0); i < numBit; i++) { + if (bits[i/NUM_BIT_PER_WORD] & (1 << (i % NUM_BIT_PER_WORD))) { + return i; + } + } + + return -1; + } + + + /* ============================================================================= + * bitmap_getNumClear + * ============================================================================= + */ + long getNumClear () { + return (numBit - getNumSet()); + } + + + /* ============================================================================= + * bitmap_getNumSet + * ============================================================================= + */ + long getNumSet () { + long i; + long count = 0; + + for (i = 0; i < numBit; i++) { + if (bits[i/NUM_BIT_PER_WORD] & (1 << (i % NUM_BIT_PER_WORD))) { + count++; + } + } + + return count; + } + + /* ============================================================================= + * bitmap_copy + * ============================================================================= + */ + //void copy(bitmap_t* dstPtr, bitmap_t* srcPtr); + // SEE COPY CONSTRUCTOR + + /* ============================================================================= + * bitmap_toggleAll + * ============================================================================= + */ + void toggleAll () { + long w; + for (w = 0; w < numWord; w++) { + bits[w] ^= -1L; + } + } + + long DIVIDE_AND_ROUND_UP(long a, long b) { + return (a/b) + (((a % b) > 0) ? (1) : (0)); + } + + long MAX(long a, long b) { + return (a > b) ? a : b; + } +} diff --git a/Robust/src/Benchmarks/SingleTM/genome/java/Bitmap.java~ b/Robust/src/Benchmarks/SingleTM/genome/java/Bitmap.java~ new file mode 100644 index 00000000..0e437075 --- /dev/null +++ b/Robust/src/Benchmarks/SingleTM/genome/java/Bitmap.java~ @@ -0,0 +1,212 @@ +public class Bitmap { + public long numBit; + public long numWord; + public long bits[]; + + private static NUM_BIT_PER_BYTE = 8; + private static NUM_BIT_PER_WORD = (8) * NUM_BIT_PER_BYTE) + + + /* ============================================================================= + * bitmap_alloc + * -- Returns NULL on failure + * ============================================================================= + */ + Bitmap(long myNumBit) { + + numBit = myNumBit; + numWord = DIVIDE_AND_ROUND_UP(numBit, NUM_BIT_PER_WORD); + + bits = new long[numWord]; + + int i = 0; + for(i = 0; i < numWord; i++) { + bits[i] = 0; + } + } + + Bitmap(Bitmap myBitMap) { + numBit = myBitMap.numBit; + numWord = myBitMap.numWord; + bits = new long[numWord]; + int i = 0; + for(i = 0; i < numWord; i++) { + bits[i] = myBitMap.bits[i]; + } + } + + /* ============================================================================= + * Pbitmap_alloc + * -- Returns NULL on failure + * ============================================================================= + */ + //bitmap_t* Pbitmap_alloc (long numBit) { } + + + /* ============================================================================= + * bitmap_free + * ============================================================================= + */ + //void bitmap_free (bitmap_t* bitmapPtr); + + + /* ============================================================================= + * Pbitmap_free + * ============================================================================= + */ + //void Pbitmap_free (bitmap_t* bitmapPtr); + + + /* ============================================================================= + * bitmap_set + * -- Sets ith bit to 1 + * -- Returns TRUE on success, else FALSE + * ============================================================================= + */ + boolean set (long i) { + if ((i < 0) || (i >= numBit)) { + return FALSE; + } + + bits[i/NUM_BIT_PER_WORD] |= (1 << (i % NUM_BIT_PER_WORD)); + + return TRUE; + } + + + /* ============================================================================= + * bitmap_clear + * -- Clears ith bit to 0 + * -- Returns TRUE on success, else FALSE + * ============================================================================= + */ + boolean clear (long i) { + if ((i < 0) || (i >= numBit)) { + return FALSE; + } + + bits[i/NUM_BIT_PER_WORD] &= ~(1 << (i % NUM_BIT_PER_WORD)); + + return TRUE; + } + + + /* ============================================================================= + * bitmap_clearAll + * -- Clears all bit to 0 + * ============================================================================= + */ + void clearAll () { + int i = 0; + for(i = 0; i < numWord; i++) { + bits[i] = 0; + } + } + + + /* ============================================================================= + * bitmap_isSet + * -- Returns TRUE if ith bit is set, else FALSE + * ============================================================================= + */ + boolean isSet (long i) { + if ((i >= 0) && (i < numBit) && + (bits[i/NUM_BIT_PER_WORD] & (1 << (i % NUM_BIT_PER_WORD)))) { + return TRUE; + } + + return FALSE; + } + + + /* ============================================================================= + * bitmap_findClear + * -- Returns index of first clear bit + * -- If start index is negative, will start from beginning + * -- If all bits are set, returns -1 + * ============================================================================= + */ + long findClear (long startIndex) { + long i; + + for (i = MAX(startIndex, 0); i < numBit; i++) { + if (!(bits[i/NUM_BIT_PER_WORD] & (1 << (i % NUM_BIT_PER_WORD)))) { + return i; + } + } + + return -1; + } + + + /* ============================================================================= + * bitmap_findSet + * -- Returns index of first set bit + * -- If all bits are clear, returns -1 + * ============================================================================= + */ + long findSet (long startIndex) { + long i; + + for (i = MAX(startIndex, 0); i < numBit; i++) { + if (bits[i/NUM_BIT_PER_WORD] & (1 << (i % NUM_BIT_PER_WORD))) { + return i; + } + } + + return -1; + } + + + /* ============================================================================= + * bitmap_getNumClear + * ============================================================================= + */ + long getNumClear () { + return (numBit - getNumSet()); + } + + + /* ============================================================================= + * bitmap_getNumSet + * ============================================================================= + */ + long getNumSet () { + long i; + long count = 0; + + for (i = 0; i < numBit; i++) { + if (bits[i/NUM_BIT_PER_WORD] & (1 << (i % NUM_BIT_PER_WORD))) { + count++; + } + } + + return count; + } + + /* ============================================================================= + * bitmap_copy + * ============================================================================= + */ + //void copy(bitmap_t* dstPtr, bitmap_t* srcPtr); + // SEE COPY CONSTRUCTOR + + /* ============================================================================= + * bitmap_toggleAll + * ============================================================================= + */ + void toggleAll () { + long w; + for (w = 0; w < numWord; w++) { + bits[w] ^= -1L; + } + } + + long DIVIDE_AND_ROUND_UP(long a, long b) { + return (a/b) + (((a % b) > 0) ? (1) : (0)); + } + + long MAX(long a, long b) { + return (a > b) ? a : b; + } +} diff --git a/Robust/src/Benchmarks/SingleTM/genome/java/Gene.java b/Robust/src/Benchmarks/SingleTM/genome/java/Gene.java new file mode 100644 index 00000000..df2f306d --- /dev/null +++ b/Robust/src/Benchmarks/SingleTM/genome/java/Gene.java @@ -0,0 +1,31 @@ +public class Gene { + public long length; + public String contents; + public Bitmap startBitmapPtr; /* used for creating segments */ + + Gene(long myLength) { + length = myLength; + contents = ""; + startBitmapPtr = new BitMap(length); + } + + +/* ============================================================================= + * gene_create + * -- Populate contents with random gene + * ============================================================================= + */ + void create (Random randomObj) { + long i; + char nucleotides[] = { + NUCLEOTIDE_ADENINE, + NUCLEOTIDE_CYTOSINE, + NUCLEOTIDE_GUANINE, + NUCLEOTIDE_THYMINE, + }; + + for (i = 0; i < length; i++) { + contents[i] = nucleotides[(random_generate(randomObj)% NUCLEOTIDE_NUM_TYPE)]; + } + } +} diff --git a/Robust/src/Benchmarks/SingleTM/genome/java/Gene.java~ b/Robust/src/Benchmarks/SingleTM/genome/java/Gene.java~ new file mode 100644 index 00000000..c78c495b --- /dev/null +++ b/Robust/src/Benchmarks/SingleTM/genome/java/Gene.java~ @@ -0,0 +1,32 @@ +public class Gene { + public long length; + public String contents; + public Bitmap startBitmapPtr; /* used for creating segments */ + + Gene(long myLength) { + length = myLength; + contents = ""; + startBitmapPtr = new BitMap(length); + } + + +/* ============================================================================= + * gene_create + * -- Populate contents with random gene + * ============================================================================= + */ + void create (Random randomObj) { + long i; + char nucleotides[] = { + NUCLEOTIDE_ADENINE, + NUCLEOTIDE_CYTOSINE, + NUCLEOTIDE_GUANINE, + NUCLEOTIDE_THYMINE, + }; + + for (i = 0; i < length; i++) { + contents[i] = + nucleotides[(random_generate(randomObj)% NUCLEOTIDE_NUM_TYPE)]; + } + } +} diff --git a/Robust/src/Benchmarks/SingleTM/genome/java/Genome.java b/Robust/src/Benchmarks/SingleTM/genome/java/Genome.java new file mode 100644 index 00000000..610f8838 --- /dev/null +++ b/Robust/src/Benchmarks/SingleTM/genome/java/Genome.java @@ -0,0 +1,147 @@ +/* +"gene.h" +"random.h" +"segments.h" +"sequencer.h" +"thread.h" +"timer.h" +"tm.h" +"vector.h" +"bitmap.h" + +*/ + +public class Genome { + long geneLength; + long segmentLength; + long minNumSegment; + long numThread; + + Genome(String x[]) { + parseCmdLine(x); + } + + public static void main(String x[]){ + +/* TIMER_T start; */ +/* TIMER_T stop; */ + +/* GOTO_REAL(); */ + + /* Initialization */ +/* parseArgs(argc, (char** const)argv); */ +/* SIM_GET_NUM_CPU(global_params[PARAM_THREAD]); */ + + System.out.print("Creating gene and segments... "); + Genome g = new Genome(x); + + +/* TM_STARTUP(numThread); */ +/* P_MEMORY_STARTUP(numThread); */ +/* thread_startup(numThread); */ + + Random randomPtr = new Random(); + random_alloc(randomPtr); + random_seed(randomPtr, 0); + + Gene genePtr = new Gene(geneLength); + genePtr.create(randomPtr); + String gene = genePtr.contents; + + Segments segmentsPtr = new Segments(segmentLength, minNumSegment); + segmentsPtr.create(genePtr, randomPtr); + sequencer_t* sequencerPtr = sequencer_alloc(geneLength, segmentLength, segmentsPtr); + assert(sequencerPtr != NULL); + + puts("done."); + printf("Gene length = %li\n", genePtr->length); + printf("Segment length = %li\n", segmentsPtr->length); + printf("Number segments = %li\n", vector_getSize(segmentsPtr->contentsPtr)); + fflush(stdout); + + /* Benchmark */ + printf("Sequencing gene... "); + fflush(stdout); + TIMER_READ(start); + GOTO_SIM(); +#ifdef OTM +#pragma omp parallel + { + sequencer_run(sequencerPtr); + } +#else + thread_start(sequencer_run, (void*)sequencerPtr); +#endif + GOTO_REAL(); + TIMER_READ(stop); + puts("done."); + printf("Time = %lf\n", TIMER_DIFF_SECONDS(start, stop)); + fflush(stdout); + + /* Check result */ + { + char* sequence = sequencerPtr->sequence; + int result = strcmp(gene, sequence); + printf("Sequence matches gene: %s\n", (result ? "no" : "yes")); + if (result) { + printf("gene = %s\n", gene); + printf("sequence = %s\n", sequence); + } + fflush(stdout); + assert(strlen(sequence) >= strlen(gene)); + } + + /* Clean up */ + printf("Deallocating memory... "); + fflush(stdout); + sequencer_free(sequencerPtr); + segments_free(segmentsPtr); + gene_free(genePtr); + random_free(randomPtr); + puts("done."); + fflush(stdout); + + TM_SHUTDOWN(); + P_MEMORY_SHUTDOWN(); + + GOTO_SIM(); + + thread_shutdown(); + + MAIN_RETURN(0); + } + + public static void parseCmdLine(String args[]) { + + int i = 0; + String arg; + while (i < args.length && args[i].startsWith("-")) { + arg = args[i++]; + //check options + if(arg.equals("-g")) { + if(i < args.length) { + geneLength = new Integer(args[i++]).intValue(); + } + } else if(arg.equals("-s")) { + if(i < args.length) { + segmentLength = new Integer(args[i++]).intValue(); + } + } else if(arg.equals("-n")) { + if(i < args.length) { + minNumSegment = new Integer(args[i++]).intValue(); + } + } else if(arg.equals("-t")) { + if(i < args.length) { + numThread = new Integer(args[i++]).intValue(); + } + } + } + } +} + +public enum param_types { + PARAM_GENE /*= (unsigned char)'g'*/, + PARAM_NUMBER /*= (unsigned char)'n'*/, + PARAM_SEGMENT /*= (unsigned char)'s'*/, + PARAM_THREAD /*= (unsigned char)'t',*/ +} diff --git a/Robust/src/Benchmarks/SingleTM/genome/java/Genome.java~ b/Robust/src/Benchmarks/SingleTM/genome/java/Genome.java~ new file mode 100644 index 00000000..40e407e3 --- /dev/null +++ b/Robust/src/Benchmarks/SingleTM/genome/java/Genome.java~ @@ -0,0 +1,148 @@ +/* +"gene.h" +"random.h" +"segments.h" +"sequencer.h" +"thread.h" +"timer.h" +"tm.h" +"vector.h" +"bitmap.h" + +*/ + +public class Genome { + long geneLength; + long segmentLength; + long minNumSegment; + long numThread; + + Genome(String x[]) { + parseCmdLine(x); + } + + public static void main(String x[]){ + +/* TIMER_T start; */ +/* TIMER_T stop; */ + +/* GOTO_REAL(); */ + + /* Initialization */ +/* parseArgs(argc, (char** const)argv); */ +/* SIM_GET_NUM_CPU(global_params[PARAM_THREAD]); */ + + System.out.print("Creating gene and segments... "); + Genome g = new Genome(x); + + +/* TM_STARTUP(numThread); */ +/* P_MEMORY_STARTUP(numThread); */ +/* thread_startup(numThread); */ + + Random randomPtr = new Random(); + random_alloc(randomPtr); + random_seed(randomPtr, 0); + + Gene genePtr = new Gene(geneLength); + genePtr.create(randomPtr); + String gene = genePtr.contents; + + Segments segmentsPtr = new Segments(segmentLength, minNumSegment); + assert(segmentsPtr != NULL); + segments_create(segmentsPtr, genePtr, randomPtr); + sequencer_t* sequencerPtr = sequencer_alloc(geneLength, segmentLength, segmentsPtr); + assert(sequencerPtr != NULL); + + puts("done."); + printf("Gene length = %li\n", genePtr->length); + printf("Segment length = %li\n", segmentsPtr->length); + printf("Number segments = %li\n", vector_getSize(segmentsPtr->contentsPtr)); + fflush(stdout); + + /* Benchmark */ + printf("Sequencing gene... "); + fflush(stdout); + TIMER_READ(start); + GOTO_SIM(); +#ifdef OTM +#pragma omp parallel + { + sequencer_run(sequencerPtr); + } +#else + thread_start(sequencer_run, (void*)sequencerPtr); +#endif + GOTO_REAL(); + TIMER_READ(stop); + puts("done."); + printf("Time = %lf\n", TIMER_DIFF_SECONDS(start, stop)); + fflush(stdout); + + /* Check result */ + { + char* sequence = sequencerPtr->sequence; + int result = strcmp(gene, sequence); + printf("Sequence matches gene: %s\n", (result ? "no" : "yes")); + if (result) { + printf("gene = %s\n", gene); + printf("sequence = %s\n", sequence); + } + fflush(stdout); + assert(strlen(sequence) >= strlen(gene)); + } + + /* Clean up */ + printf("Deallocating memory... "); + fflush(stdout); + sequencer_free(sequencerPtr); + segments_free(segmentsPtr); + gene_free(genePtr); + random_free(randomPtr); + puts("done."); + fflush(stdout); + + TM_SHUTDOWN(); + P_MEMORY_SHUTDOWN(); + + GOTO_SIM(); + + thread_shutdown(); + + MAIN_RETURN(0); + } + + public static void parseCmdLine(String args[]) { + + int i = 0; + String arg; + while (i < args.length && args[i].startsWith("-")) { + arg = args[i++]; + //check options + if(arg.equals("-g")) { + if(i < args.length) { + geneLength = new Integer(args[i++]).intValue(); + } + } else if(arg.equals("-s")) { + if(i < args.length) { + segmentLength = new Integer(args[i++]).intValue(); + } + } else if(arg.equals("-n")) { + if(i < args.length) { + minNumSegment = new Integer(args[i++]).intValue(); + } + } else if(arg.equals("-t")) { + if(i < args.length) { + numThread = new Integer(args[i++]).intValue(); + } + } + } + } +} + +public enum param_types { + PARAM_GENE /*= (unsigned char)'g'*/, + PARAM_NUMBER /*= (unsigned char)'n'*/, + PARAM_SEGMENT /*= (unsigned char)'s'*/, + PARAM_THREAD /*= (unsigned char)'t',*/ +} diff --git a/Robust/src/Benchmarks/SingleTM/genome/java/List.java b/Robust/src/Benchmarks/SingleTM/genome/java/List.java new file mode 100644 index 00000000..310e51b8 --- /dev/null +++ b/Robust/src/Benchmarks/SingleTM/genome/java/List.java @@ -0,0 +1,256 @@ +public class List { + +private class list_node { + void* dataPtr; + struct list_node* nextPtr; +} + +typedef list_node_t* list_iter_t; + + list_node_t head; + long (*compare)(const void*, const void*); /* returns {-1,0,1}, 0 -> equal */ + long size; +} list_t; + + +/* ============================================================================= + * list_iter_reset + * ============================================================================= + */ +void +list_iter_reset (list_iter_t* itPtr, list_t* listPtr); + + +/* ============================================================================= + * TMlist_iter_reset + * ============================================================================= + */ +TM_CALLABLE +void +TMlist_iter_reset (TM_ARGDECL list_iter_t* itPtr, list_t* listPtr); + + +/* ============================================================================= + * list_iter_hasNext + * ============================================================================= + */ +bool_t +list_iter_hasNext (list_iter_t* itPtr, list_t* listPtr); + + +/* ============================================================================= + * TMlist_iter_hasNext + * ============================================================================= + */ +TM_CALLABLE +bool_t +TMlist_iter_hasNext (TM_ARGDECL list_iter_t* itPtr, list_t* listPtr); + + +/* ============================================================================= + * list_iter_next + * ============================================================================= + */ +void* +list_iter_next (list_iter_t* itPtr, list_t* listPtr); + + +/* ============================================================================= + * TMlist_iter_next + * ============================================================================= + */ +TM_CALLABLE +void* +TMlist_iter_next (TM_ARGDECL list_iter_t* itPtr, list_t* listPtr); + + +/* ============================================================================= + * list_alloc + * -- If NULL passed for 'compare' function, will compare data pointer addresses + * -- Returns NULL on failure + * ============================================================================= + */ +list_t* +list_alloc (long (*compare)(const void*, const void*)); + + +/* ============================================================================= + * Plist_alloc + * -- If NULL passed for 'compare' function, will compare data pointer addresses + * -- Returns NULL on failure + * ============================================================================= + */ +list_t* +Plist_alloc (long (*compare)(const void*, const void*)); + + +/* ============================================================================= + * TMlist_alloc + * -- If NULL passed for 'compare' function, will compare data pointer addresses + * -- Returns NULL on failure + * ============================================================================= + */ +list_t* +TMlist_alloc (TM_ARGDECL long (*compare)(const void*, const void*)); + + +/* ============================================================================= + * list_free + * ============================================================================= + */ +void +list_free (list_t* listPtr); + + +/* ============================================================================= + * Plist_free + * -- If NULL passed for 'compare' function, will compare data pointer addresses + * -- Returns NULL on failure + * ============================================================================= + */ +void +Plist_free (list_t* listPtr); + + +/* ============================================================================= + * TMlist_free + * -- If NULL passed for 'compare' function, will compare data pointer addresses + * -- Returns NULL on failure + * ============================================================================= + */ +void +TMlist_free (TM_ARGDECL list_t* listPtr); + + + +/* ============================================================================= + * list_isEmpty + * -- Return TRUE if list is empty, else FALSE + * ============================================================================= + */ +bool_t +list_isEmpty (list_t* listPtr); + + +/* ============================================================================= + * TMlist_isEmpty + * -- Return TRUE if list is empty, else FALSE + * ============================================================================= + */ +TM_CALLABLE +bool_t +TMlist_isEmpty (TM_ARGDECL list_t* listPtr); + + +/* ============================================================================= + * list_getSize + * -- Returns size of list + * ============================================================================= + */ +long +list_getSize (list_t* listPtr); + + +/* ============================================================================= + * TMlist_getSize + * -- Returns size of list + * ============================================================================= + */ +TM_CALLABLE +long +TMlist_getSize (TM_ARGDECL list_t* listPtr); + + +/* ============================================================================= + * list_find + * -- Returns NULL if not found, else returns pointer to data + * ============================================================================= + */ +void* +list_find (list_t* listPtr, void* dataPtr); + + +/* ============================================================================= + * TMlist_find + * -- Returns NULL if not found, else returns pointer to data + * ============================================================================= + */ +TM_CALLABLE +void* +TMlist_find (TM_ARGDECL list_t* listPtr, void* dataPtr); + + +/* ============================================================================= + * list_insert + * -- Return TRUE on success, else FALSE + * ============================================================================= + */ +bool_t +list_insert (list_t* listPtr, void* dataPtr); + + +/* ============================================================================= + * Plist_insert + * -- Return TRUE on success, else FALSE + * ============================================================================= + */ +bool_t +Plist_insert (list_t* listPtr, void* dataPtr); + + +/* ============================================================================= + * TMlist_insert + * -- Return TRUE on success, else FALSE + * ============================================================================= + */ +TM_CALLABLE +bool_t +TMlist_insert (TM_ARGDECL list_t* listPtr, void* dataPtr); + + +/* ============================================================================= + * list_remove + * -- Returns TRUE if successful, else FALSE + * ============================================================================= + */ +bool_t +list_remove (list_t* listPtr, void* dataPtr); + + +/* ============================================================================= + * Plist_remove + * -- Returns TRUE if successful, else FALSE + * ============================================================================= + */ +bool_t +Plist_remove (list_t* listPtr, void* dataPtr); + + +/* ============================================================================= + * TMlist_remove + * -- Returns TRUE if successful, else FALSE + * ============================================================================= + */ +TM_CALLABLE +bool_t +TMlist_remove (TM_ARGDECL list_t* listPtr, void* dataPtr); + + +/* ============================================================================= + * list_clear + * -- Removes all elements + * ============================================================================= + */ +void +list_clear (list_t* listPtr); + + +/* ============================================================================= + * Plist_clear + * -- Removes all elements + * ============================================================================= + */ +void +Plist_clear (list_t* listPtr); + +} diff --git a/Robust/src/Benchmarks/SingleTM/genome/java/List.java~ b/Robust/src/Benchmarks/SingleTM/genome/java/List.java~ new file mode 100644 index 00000000..0b409c66 --- /dev/null +++ b/Robust/src/Benchmarks/SingleTM/genome/java/List.java~ @@ -0,0 +1,4 @@ +public class List { + + +} diff --git a/Robust/src/Benchmarks/SingleTM/genome/java/Random.java b/Robust/src/Benchmarks/SingleTM/genome/java/Random.java new file mode 100644 index 00000000..819abe26 --- /dev/null +++ b/Robust/src/Benchmarks/SingleTM/genome/java/Random.java @@ -0,0 +1,96 @@ +public class Random { + long[] mt; + int mti; + long RANDOM_DEFAULT_SEED; + /* period parameter */ + int N; + int M; + long MATRIX_A; + long UPPER_MASK; + long LOWER_MASK; + + public Random() { + RANDOM_DEFAULT_SEED = 0L; + N = 624; + M = 397; + mt = new long[N]; + mti = 0; + MATRIX_A = 0x9908b0dfL; /* constant vector a */ + UPPER_MASK = 0x80000000L; /* most significant w-r bits */ + LOWER_MASK = 0x7fffffffL; /* least significant r bits */ + } + + public Random random_alloc(Random rand) { + init_genrand(rand, rand.RANDOM_DEFAULT_SEED); + return rand; + } + + /* initializes mt[N] with a seed */ + public void init_genrand(Random rand, long s) { + int mti; + + rand.mt[0]= s & 0xFFFFFFFFL; + for (mti=1; mti> 30)) + mti); + /* See Knuth TAOCP Vol2. 3rd Ed. P.106 for multiplier. */ + /* In the previous versions, MSBs of the seed affect */ + /* only MSBs of the array mt[]. */ + /* 2002/01/09 modified by Makoto Matsumoto */ + rand.mt[mti] &= 0xFFFFFFFFL; + /* for >32 bit machines */ + } + + rand.mti = mti; + } + + public void random_seed(Random rand, long seed) { + init_genrand(rand, seed); + } + + public long random_generate(Random rand) { + return genrand_int32(rand); + } + + //public static long genrand_int32(long[] mt, long mtiPtr) { + public long genrand_int32(Random rand) { + long y; + long[] mag01= new long[2]; + mag01[0] = 0x0L; + mag01[1] = rand.MATRIX_A; + int mti = rand.mti; + + /* mag01[x] = x * MATRIX_A for x=0,1 */ + + if (mti >= rand.N) { /* generate N words at one time */ + int kk; + + if (mti == rand.N+1) /* if init_genrand() has not been called, */ + init_genrand(rand, 5489L); /* a default initial seed is used */ + + for (kk=0;kk> 1) ^ mag01[(int)(y & 0x1L)]; + } + for (;kk> 1) ^ mag01[(int)(y & 0x1L)]; + } + y = (rand.mt[N-1]&rand.UPPER_MASK)|(rand.mt[0]&LOWER_MASK); + rand.mt[N-1] = rand.mt[M-1] ^ (y >> 1) ^ mag01[(int)(y & 0x1L)]; + + mti = 0; + } + + y = rand.mt[mti++]; + + /* Tempering */ + y ^= (y >> 11); + y ^= (y << 7) & 0x9d2c5680L; + y ^= (y << 15) & 0xefc60000L; + y ^= (y >> 18); + + rand.mti = mti; + + return y; + } +} diff --git a/Robust/src/Benchmarks/SingleTM/genome/java/Segments.java b/Robust/src/Benchmarks/SingleTM/genome/java/Segments.java new file mode 100644 index 00000000..d685eef4 --- /dev/null +++ b/Robust/src/Benchmarks/SingleTM/genome/java/Segments.java @@ -0,0 +1,70 @@ +public class Segments { + public long length; + public long minNum; + Vector contentsPtr; +/* private: */ + String strings[]; + + Segments (long myLength, long myMinNum) { + minNum = myMinNum; + length = myLength; + + contentsPtr = new Vector(minNum); + + } + + + /* ============================================================================= + * segments_create + * -- Populates 'contentsPtr' + * ============================================================================= + */ + void create (Gene genePtr, Random randomPtr) { + String geneString; + long geneLength; + Bitmap startBitmapPtr; + long numStart; + long i; + long maxZeroRunLength; + + geneString = genePtr.contents; + geneLength = genePtr.length; + startBitmapPtr = genePtr.startBitmapPtr; + numStart = geneLength - segmentLength + 1; + + /* Pick some random segments to start */ + for (i = 0; i < minNumSegment; i++) { + long j = (long)(random_generate(randomPtr) % numStart); + boolean status = startBitmapPtr.set(j); + strings[i] = geneString[j]; + segmentsContentsPtr.add(strings[i]); + } + + /* Make sure segment covers start */ + i = 0; + if (!startBitmapPtr.isSet(i)) { + String string; + string = geneString[i]; + segmentsContentsPtr.add(string); + startBitmapPtr.set(i); + } + + /* Add extra segments to fill holes and ensure overlap */ + maxZeroRunLength = length - 1; + for (i = 0; i < numStart; i++) { + long i_stop = MIN((i+maxZeroRunLength), numStart); + for ( /* continue */; i < i_stop; i++) { + if (startBitmapPtr.isSet(i)) { + break; + } + } + if (i == i_stop) { + /* Found big enough hole */ + i = i - 1; + String string = geneString[i]; + segmentsContentsPtr.add(string); + startBitmapPtr.set(i); + } + } + } +} diff --git a/Robust/src/Benchmarks/SingleTM/genome/java/Segments.java~ b/Robust/src/Benchmarks/SingleTM/genome/java/Segments.java~ new file mode 100644 index 00000000..accbdcb3 --- /dev/null +++ b/Robust/src/Benchmarks/SingleTM/genome/java/Segments.java~ @@ -0,0 +1,71 @@ +public class Segments { + public long length; + public long minNum; + Vector contentsPtr; +/* private: */ + String strings[]; + + Segments (long myLength, long myMinNum) { + minNum = myMinNum; + length = myLength; + + contentsPtr = new Vector(minNum); + + } + + + /* ============================================================================= + * segments_create + * -- Populates 'contentsPtr' + * ============================================================================= + */ + void create (Gene genePtr, Random randomPtr) { + String geneString; + long geneLength; + Bitmap startBitmapPtr; + long numStart; + long i; + long maxZeroRunLength; + + geneString = genePtr.contents; + geneLength = genePtr.length; + startBitmapPtr = genePtr.startBitmapPtr; + numStart = geneLength - segmentLength + 1; + + /* Pick some random segments to start */ + for (i = 0; i < minNumSegment; i++) { + long j = (long)(random_generate(randomPtr) % numStart); + boolean status = startBitmapPtr.set(j); + strings[i] = geneString[j]; + segmentsContentsPtr.add(strings[i]); + } + + /* Make sure segment covers start */ + i = 0; + if (!startBitmapPtr.isSet(i)) { + String string; + string = geneString[i]; + segmentsContentsPtr.add(string); + startBitmapPtr.set(i); + } + + /* Add extra segments to fill holes and ensure overlap */ + maxZeroRunLength = length - 1; + for (i = 0; i < numStart; i++) { + long i_stop = MIN((i+maxZeroRunLength), numStart); + for ( /* continue */; i < i_stop; i++) { + if (startBitmapPtr.isSet(i)) { + break; + } + } + if (i == i_stop) { + /* Found big enough hole */ + i = i - 1; + String string = geneString[i]; + segmentsContentsPtr.add(string); + startBitmapPtr.set(i); + assert(status); + } + } + } +} diff --git a/Robust/src/Benchmarks/SingleTM/genome/java/Sequencer.java b/Robust/src/Benchmarks/SingleTM/genome/java/Sequencer.java new file mode 100644 index 00000000..a8c81b9f --- /dev/null +++ b/Robust/src/Benchmarks/SingleTM/genome/java/Sequencer.java @@ -0,0 +1,510 @@ +public class Sequencer { + + public char* sequence; + + public Segments segmentsPtr; + + /* For removing duplicate segments */ + Hashmap uniqueSegmentsPtr; + + /* For matching segments */ + endInfoEntry endInfoEntries[]; + Table startHashToConstructEntryTables[]; + + /* For constructing sequence */ + constructEntry constructEntries[]; + Table hashToConstructEntryTable; + + /* For deallocation */ + long segmentLength; + + + /* ============================================================================= + * sequencer_alloc + * -- Returns NULL on failure + * ============================================================================= + */ + Sequencer (long myGeneLength, long mySegmentLength, Segments mySegmentsPtr) { + + long maxNumUniqueSegment = myGeneLength - mySegmentLength + 1; + long i; + + uniqueSegmentsPtr = new Hashmap(myGeneLength); + + /* For finding a matching entry */ + endInfoEntries = new endInfoEntry[maxNumUniqueSegment]; + for (i = 0; i < maxNumUniqueSegment; i++) { + endInfoEntries[i].isEnd = TRUE; + endInfoEntries[i].jumpToNext = 1; + } + startHashToConstructEntryTables = new Table[mySegmentLength]; + for (i = 1; i < mySegmentLength; i++) { /* 0 is dummy entry */ + startHashToConstructEntryTables[i] = new Table(myGeneLength); + } + segmentLength = mySegmentLength; + + /* For constructing sequence */ + constructEntries = new ContructEntry[maxNumUniqueSegment]; + + for (i= 0; i < maxNumUniqueSegment; i++) { + constructEntries[i].isStart = TRUE; + constructEntries[i].segment = NULL; + constructEntries[i].endHash = 0; + constructEntries[i].startPtr = constructEntries[i]; + constructEntries[i].nextPtr = NULL; + constructEntries[i].endPtr = constructEntries[i]; + constructEntries[i].overlap = 0; + constructEntries[i].length = segmentLength; + } + hashToConstructEntryTable = new Table(geneLength); + + segmentsPtr = mySegmentsPtr; + } + + + /* ============================================================================= + * sequencer_run + * ============================================================================= + */ + + void run () { + + //TM_THREAD_ENTER(); + + long threadId = thread_getId(); + + //Sequencer sequencerPtr = (sequencer_t*)argPtr; + + Hashmap uniqueSegmentsPtr; + endInfoEntry endInfoEntries[]; + Hashmap startHashToConstructEntryTables[]; + constructEntry constructEntries[]; + Hashmap hashToConstructEntryTable; + + Vector segmentsContentsPtr = segmentsPtr.contentsPtr; + long numSegment = segmentsContentsPtr.size(); + long segmentLength = segmentsPtr.length; + + long i; + long j; + long i_start; + long i_stop; + long numUniqueSegment; + long substringLength; + long entryIndex; + + /* + * Step 1: Remove duplicate segments + */ +#if defined(HTM) || defined(STM) + long numThread = thread_getNumThread(); + { + /* Choose disjoint segments [i_start,i_stop) for each thread */ + long partitionSize = (numSegment + numThread/2) / numThread; /* with rounding */ + i_start = threadId * partitionSize; + if (threadId == (numThread - 1)) { + i_stop = numSegment; + } else { + i_stop = i_start + partitionSize; + } + } +#else /* !(HTM || STM) */ + i_start = 0; + i_stop = numSegment; +#endif /* !(HTM || STM) */ + for (i = i_start; i < i_stop; i+=CHUNK_STEP1) { + TM_BEGIN(); + { + long ii; + long ii_stop = MIN(i_stop, (i+CHUNK_STEP1)); + for (ii = i; ii < ii_stop; ii++) { + string segment = segmentsContentsPtr.get(ii); + TMHASHTABLE_INSERT(uniqueSegmentsPtr, + segment, + segment); + } /* ii */ + } + TM_END(); + } + + thread_barrier_wait(); + + /* + * Step 2a: Iterate over unique segments and compute hashes. + * + * For the gene "atcg", the hashes for the end would be: + * + * "t", "tc", and "tcg" + * + * And for the gene "tcgg", the hashes for the start would be: + * + * "t", "tc", and "tcg" + * + * The names are "end" and "start" because if a matching pair is found, + * they are the substring of the end part of the pair and the start + * part of the pair respectively. In the above example, "tcg" is the + * matching substring so: + * + * (end) (start) + * a[tcg] + [tcg]g = a[tcg]g (overlap = "tcg") + */ + + /* uniqueSegmentsPtr is constant now */ + numUniqueSegment = hashtable_getSize(uniqueSegmentsPtr); + entryIndex = 0; + +#if defined(HTM) || defined(STM) + { + /* Choose disjoint segments [i_start,i_stop) for each thread */ + long num = uniqueSegmentsPtr->numBucket; + long partitionSize = (num + numThread/2) / numThread; /* with rounding */ + i_start = threadId * partitionSize; + if (threadId == (numThread - 1)) { + i_stop = num; + } else { + i_stop = i_start + partitionSize; + } + } + { + /* Approximate disjoint segments of element allocation in constructEntries */ + long partitionSize = (numUniqueSegment + numThread/2) / numThread; /* with rounding */ + entryIndex = threadId * partitionSize; + } +#else /* !(HTM || STM) */ + i_start = 0; + i_stop = uniqueSegmentsPtr->numBucket; + entryIndex = 0; +#endif /* !(HTM || STM) */ + + for (i = i_start; i < i_stop; i++) { + + list_t* chainPtr = uniqueSegmentsPtr->buckets[i]; + list_iter_t it; + list_iter_reset(&it, chainPtr); + + while (list_iter_hasNext(&it, chainPtr)) { + + char* segment = + (char*)((pair_t*)list_iter_next(&it, chainPtr))->firstPtr; + constructEntry_t* constructEntryPtr; + long j; + ulong_t startHash; + bool_t status; + + /* Find an empty constructEntries entry */ + TM_BEGIN(); + while (((void*)TM_SHARED_READ_P(constructEntries[entryIndex].segment)) != NULL) { + entryIndex = (entryIndex + 1) % numUniqueSegment; /* look for empty */ + } + constructEntryPtr = &constructEntries[entryIndex]; + TM_SHARED_WRITE_P(constructEntryPtr->segment, segment); + TM_END(); + entryIndex = (entryIndex + 1) % numUniqueSegment; + + /* + * Save hashes (sdbm algorithm) of segment substrings + * + * endHashes will be computed for shorter substrings after matches + * have been made (in the next phase of the code). This will reduce + * the number of substrings for which hashes need to be computed. + * + * Since we can compute startHashes incrementally, we go ahead + * and compute all of them here. + */ + /* constructEntryPtr is local now */ + constructEntryPtr->endHash = (ulong_t)hashString(&segment[1]); + + startHash = 0; + for (j = 1; j < segmentLength; j++) { + startHash = (ulong_t)segment[j-1] + + (startHash << 6) + (startHash << 16) - startHash; + TM_BEGIN(); + status = TMTABLE_INSERT(startHashToConstructEntryTables[j], + (ulong_t)startHash, + (void*)constructEntryPtr ); + TM_END(); + assert(status); + } + + /* + * For looking up construct entries quickly + */ + startHash = (ulong_t)segment[j-1] + + (startHash << 6) + (startHash << 16) - startHash; + TM_BEGIN(); + status = TMTABLE_INSERT(hashToConstructEntryTable, + (ulong_t)startHash, + (void*)constructEntryPtr); + TM_END(); + assert(status); + } + } + + thread_barrier_wait(); + + /* + * Step 2b: Match ends to starts by using hash-based string comparison. + */ + for (substringLength = segmentLength-1; substringLength > 0; substringLength--) { + + table_t* startHashToConstructEntryTablePtr = + startHashToConstructEntryTables[substringLength]; + list_t** buckets = startHashToConstructEntryTablePtr->buckets; + long numBucket = startHashToConstructEntryTablePtr->numBucket; + + long index_start; + long index_stop; + +#if defined(HTM) || defined(STM) + { + /* Choose disjoint segments [index_start,index_stop) for each thread */ + long partitionSize = (numUniqueSegment + numThread/2) / numThread; /* with rounding */ + index_start = threadId * partitionSize; + if (threadId == (numThread - 1)) { + index_stop = numUniqueSegment; + } else { + index_stop = index_start + partitionSize; + } + } +#else /* !(HTM || STM) */ + index_start = 0; + index_stop = numUniqueSegment; +#endif /* !(HTM || STM) */ + + /* Iterating over disjoint itervals in the range [0, numUniqueSegment) */ + for (entryIndex = index_start; + entryIndex < index_stop; + entryIndex += endInfoEntries[entryIndex].jumpToNext) + { + if (!endInfoEntries[entryIndex].isEnd) { + continue; + } + + /* ConstructEntries[entryIndex] is local data */ + constructEntry_t* endConstructEntryPtr = + &constructEntries[entryIndex]; + char* endSegment = endConstructEntryPtr->segment; + ulong_t endHash = endConstructEntryPtr->endHash; + + list_t* chainPtr = buckets[endHash % numBucket]; /* buckets: constant data */ + list_iter_t it; + list_iter_reset(&it, chainPtr); + + /* Linked list at chainPtr is constant */ + while (list_iter_hasNext(&it, chainPtr)) { + + constructEntry_t* startConstructEntryPtr = + (constructEntry_t*)list_iter_next(&it, chainPtr); + char* startSegment = startConstructEntryPtr->segment; + long newLength = 0; + + /* endConstructEntryPtr is local except for properties startPtr/endPtr/length */ + TM_BEGIN(); + + /* Check if matches */ + if (TM_SHARED_READ(startConstructEntryPtr->isStart) && + (TM_SHARED_READ_P(endConstructEntryPtr->startPtr) != startConstructEntryPtr) && + (strncmp(startSegment, + &endSegment[segmentLength - substringLength], + substringLength) == 0)) + { + TM_SHARED_WRITE(startConstructEntryPtr->isStart, FALSE); + + constructEntry_t* startConstructEntry_endPtr; + constructEntry_t* endConstructEntry_startPtr; + + /* Update endInfo (appended something so no longer end) */ + TM_LOCAL_WRITE(endInfoEntries[entryIndex].isEnd, FALSE); + + /* Update segment chain construct info */ + startConstructEntry_endPtr = + (constructEntry_t*)TM_SHARED_READ_P(startConstructEntryPtr->endPtr); + endConstructEntry_startPtr = + (constructEntry_t*)TM_SHARED_READ_P(endConstructEntryPtr->startPtr); + + assert(startConstructEntry_endPtr); + assert(endConstructEntry_startPtr); + TM_SHARED_WRITE_P(startConstructEntry_endPtr->startPtr, + endConstructEntry_startPtr); + TM_LOCAL_WRITE_P(endConstructEntryPtr->nextPtr, + startConstructEntryPtr); + TM_SHARED_WRITE_P(endConstructEntry_startPtr->endPtr, + startConstructEntry_endPtr); + TM_SHARED_WRITE(endConstructEntryPtr->overlap, substringLength); + newLength = (long)TM_SHARED_READ(endConstructEntry_startPtr->length) + + (long)TM_SHARED_READ(startConstructEntryPtr->length) - + substringLength; + TM_SHARED_WRITE(endConstructEntry_startPtr->length, newLength); + } /* if (matched) */ + + TM_END(); + + if (!endInfoEntries[entryIndex].isEnd) { /* if there was a match */ + break; + } + } /* iterate over chain */ + + } /* for (endIndex < numUniqueSegment) */ + + thread_barrier_wait(); + + /* + * Step 2c: Update jump values and hashes + * + * endHash entries of all remaining ends are updated to the next + * substringLength. Additionally jumpToNext entries are updated such + * that they allow to skip non-end entries. Currently this is sequential + * because parallelization did not perform better. +. */ + + if (threadId == 0) { + if (substringLength > 1) { + long index = segmentLength - substringLength + 1; + /* initialization if j and i: with i being the next end after j=0 */ + for (i = 1; !endInfoEntries[i].isEnd; i+=endInfoEntries[i].jumpToNext) { + /* find first non-null */ + } + /* entry 0 is handled seperately from the loop below */ + endInfoEntries[0].jumpToNext = i; + if (endInfoEntries[0].isEnd) { + constructEntry_t* constructEntryPtr = &constructEntries[0]; + char* segment = constructEntryPtr->segment; + constructEntryPtr->endHash = (ulong_t)hashString(&segment[index]); + } + /* Continue scanning (do not reset i) */ + for (j = 0; i < numUniqueSegment; i+=endInfoEntries[i].jumpToNext) { + if (endInfoEntries[i].isEnd) { + constructEntry_t* constructEntryPtr = &constructEntries[i]; + char* segment = constructEntryPtr->segment; + constructEntryPtr->endHash = (ulong_t)hashString(&segment[index]); + endInfoEntries[j].jumpToNext = MAX(1, (i - j)); + j = i; + } + } + endInfoEntries[j].jumpToNext = i - j; + } + } + + thread_barrier_wait(); + + } /* for (substringLength > 0) */ + + + thread_barrier_wait(); + + /* + * Step 3: Build sequence string + */ + if (threadId == 0) { + + long totalLength = 0; + + for (i = 0; i < numUniqueSegment; i++) { + constructEntry_t* constructEntryPtr = &constructEntries[i]; + if (constructEntryPtr->isStart) { + totalLength += constructEntryPtr->length; + } + } + + sequencerPtr->sequence = (char*)P_MALLOC((totalLength+1) * sizeof(char)); + char* sequence = sequencerPtr->sequence; + assert(sequence); + + char* copyPtr = sequence; + long sequenceLength = 0; + + for (i = 0; i < numUniqueSegment; i++) { + constructEntry_t* constructEntryPtr = &constructEntries[i]; + /* If there are several start segments, we append in arbitrary order */ + if (constructEntryPtr->isStart) { + long newSequenceLength = sequenceLength + constructEntryPtr->length; + assert( newSequenceLength <= totalLength ); + copyPtr = sequence + sequenceLength; + sequenceLength = newSequenceLength; + do { + long numChar = segmentLength - constructEntryPtr->overlap; + if ((copyPtr + numChar) > (sequence + newSequenceLength)) { + TM_PRINT0("ERROR: sequence length != actual length\n"); + break; + } + memcpy(copyPtr, + constructEntryPtr->segment, + (numChar * sizeof(char))); + copyPtr += numChar; + } while ((constructEntryPtr = constructEntryPtr->nextPtr) != NULL); + assert(copyPtr <= (sequence + sequenceLength)); + } + } + + assert(sequence != NULL); + sequence[sequenceLength] = '\0'; + } + + TM_THREAD_EXIT(); + + } + + + private class endInfoEntry { + boolean isEnd; + long jumpToNext; + } + + private class constructEntry { + boolean isStart; + String segment; + long endHash; + constructEntry startPtr; + constructEntry nextPtr; + constructEntry endPtr; + long overlap; + long length; + } + + private class sequencer_run_arg { + Sequencer sequencerPtr; + Segments segmentsPtr; + long preAllocLength; + String returnSequence; /* variable stores return value */ + } + /* ============================================================================= + * hashString + * -- uses sdbm hash function + * ============================================================================= + */ + static long hashString (String str) + { + long hash = 0; + long c; + + /* Note: Do not change this hashing scheme */ + while ((c = str++) != '\0') { + hash = c + (hash << 6) + (hash << 16) - hash; + } + + return (long)hash; + } + + + /* ============================================================================= + * hashSegment + * -- For hashtable + * ============================================================================= + */ + static long hashSegment (string keyPtr) + { + return (long)hash_sdbm(keyPtr); /* can be any "good" hash function */ + } + + + /* ============================================================================= + * compareSegment + * -- For hashtable + * ============================================================================= + */ + static long compareSegment (pair_t* a, pair_t* b) + { + return strcmp((char*)(a->firstPtr), (char*)(b->firstPtr)); + } + +} diff --git a/Robust/src/Benchmarks/SingleTM/genome/java/Sequencer.java~ b/Robust/src/Benchmarks/SingleTM/genome/java/Sequencer.java~ new file mode 100644 index 00000000..b5895aac --- /dev/null +++ b/Robust/src/Benchmarks/SingleTM/genome/java/Sequencer.java~ @@ -0,0 +1,510 @@ +public class Sequencer { + + public char* sequence; + + public Segments segmentsPtr; + + /* For removing duplicate segments */ + Hashmap uniqueSegmentsPtr; + + /* For matching segments */ + endInfoEntry endInfoEntries[]; + Table startHashToConstructEntryTables[]; + + /* For constructing sequence */ + constructEntry constructEntries[]; + Table hashToConstructEntryTable; + + /* For deallocation */ + long segmentLength; + + + /* ============================================================================= + * sequencer_alloc + * -- Returns NULL on failure + * ============================================================================= + */ + Sequencer (long myGeneLength, long mySegmentLength, Segments mySegmentsPtr) { + + long maxNumUniqueSegment = myGeneLength - mySegmentLength + 1; + long i; + + uniqueSegmentsPtr = new Hashmap(myGeneLength); + + /* For finding a matching entry */ + endInfoEntries = new endInfoEntry[maxNumUniqueSegment]; + for (i = 0; i < maxNumUniqueSegment; i++) { + endInfoEntries[i].isEnd = TRUE; + endInfoEntries[i].jumpToNext = 1; + } + startHashToConstructEntryTables = new Table[mySegmentLength]; + for (i = 1; i < mySegmentLength; i++) { /* 0 is dummy entry */ + startHashToConstructEntryTables[i] = new Table(myGeneLength); + } + segmentLength = mySegmentLength; + + /* For constructing sequence */ + constructEntries = new ContructEntry[maxNumUniqueSegment]; + + for (i= 0; i < maxNumUniqueSegment; i++) { + constructEntries[i].isStart = TRUE; + constructEntries[i].segment = NULL; + constructEntries[i].endHash = 0; + constructEntries[i].startPtr = constructEntries[i]; + constructEntries[i].nextPtr = NULL; + constructEntries[i].endPtr = constructEntries[i]; + constructEntries[i].overlap = 0; + constructEntries[i].length = segmentLength; + } + hashToConstructEntryTable = new Table(geneLength); + + segmentsPtr = mySegmentsPtr; + } + + + /* ============================================================================= + * sequencer_run + * ============================================================================= + */ + + void run () { + + //TM_THREAD_ENTER(); + + long threadId = thread_getId(); + + //Sequencer sequencerPtr = (sequencer_t*)argPtr; + + Hashmap uniqueSegmentsPtr; + endInfoEntry endInfoEntries[]; + Hashmap startHashToConstructEntryTables[]; + constructEntry constructEntries[]; + Hashmap hashToConstructEntryTable; + + Vector segmentsContentsPtr = segmentsPtr.contentsPtr; + long numSegment = segmentsContentsPtr.size(); + long segmentLength = segmentsPtr.length; + + long i; + long j; + long i_start; + long i_stop; + long numUniqueSegment; + long substringLength; + long entryIndex; + + /* + * Step 1: Remove duplicate segments + */ +#if defined(HTM) || defined(STM) + long numThread = thread_getNumThread(); + { + /* Choose disjoint segments [i_start,i_stop) for each thread */ + long partitionSize = (numSegment + numThread/2) / numThread; /* with rounding */ + i_start = threadId * partitionSize; + if (threadId == (numThread - 1)) { + i_stop = numSegment; + } else { + i_stop = i_start + partitionSize; + } + } +#else /* !(HTM || STM) */ + i_start = 0; + i_stop = numSegment; +#endif /* !(HTM || STM) */ + for (i = i_start; i < i_stop; i+=CHUNK_STEP1) { + TM_BEGIN(); + { + long ii; + long ii_stop = MIN(i_stop, (i+CHUNK_STEP1)); + for (ii = i; ii < ii_stop; ii++) { + void* segment = vector_at(segmentsContentsPtr, ii); + TMHASHTABLE_INSERT(uniqueSegmentsPtr, + segment, + segment); + } /* ii */ + } + TM_END(); + } + + thread_barrier_wait(); + + /* + * Step 2a: Iterate over unique segments and compute hashes. + * + * For the gene "atcg", the hashes for the end would be: + * + * "t", "tc", and "tcg" + * + * And for the gene "tcgg", the hashes for the start would be: + * + * "t", "tc", and "tcg" + * + * The names are "end" and "start" because if a matching pair is found, + * they are the substring of the end part of the pair and the start + * part of the pair respectively. In the above example, "tcg" is the + * matching substring so: + * + * (end) (start) + * a[tcg] + [tcg]g = a[tcg]g (overlap = "tcg") + */ + + /* uniqueSegmentsPtr is constant now */ + numUniqueSegment = hashtable_getSize(uniqueSegmentsPtr); + entryIndex = 0; + +#if defined(HTM) || defined(STM) + { + /* Choose disjoint segments [i_start,i_stop) for each thread */ + long num = uniqueSegmentsPtr->numBucket; + long partitionSize = (num + numThread/2) / numThread; /* with rounding */ + i_start = threadId * partitionSize; + if (threadId == (numThread - 1)) { + i_stop = num; + } else { + i_stop = i_start + partitionSize; + } + } + { + /* Approximate disjoint segments of element allocation in constructEntries */ + long partitionSize = (numUniqueSegment + numThread/2) / numThread; /* with rounding */ + entryIndex = threadId * partitionSize; + } +#else /* !(HTM || STM) */ + i_start = 0; + i_stop = uniqueSegmentsPtr->numBucket; + entryIndex = 0; +#endif /* !(HTM || STM) */ + + for (i = i_start; i < i_stop; i++) { + + list_t* chainPtr = uniqueSegmentsPtr->buckets[i]; + list_iter_t it; + list_iter_reset(&it, chainPtr); + + while (list_iter_hasNext(&it, chainPtr)) { + + char* segment = + (char*)((pair_t*)list_iter_next(&it, chainPtr))->firstPtr; + constructEntry_t* constructEntryPtr; + long j; + ulong_t startHash; + bool_t status; + + /* Find an empty constructEntries entry */ + TM_BEGIN(); + while (((void*)TM_SHARED_READ_P(constructEntries[entryIndex].segment)) != NULL) { + entryIndex = (entryIndex + 1) % numUniqueSegment; /* look for empty */ + } + constructEntryPtr = &constructEntries[entryIndex]; + TM_SHARED_WRITE_P(constructEntryPtr->segment, segment); + TM_END(); + entryIndex = (entryIndex + 1) % numUniqueSegment; + + /* + * Save hashes (sdbm algorithm) of segment substrings + * + * endHashes will be computed for shorter substrings after matches + * have been made (in the next phase of the code). This will reduce + * the number of substrings for which hashes need to be computed. + * + * Since we can compute startHashes incrementally, we go ahead + * and compute all of them here. + */ + /* constructEntryPtr is local now */ + constructEntryPtr->endHash = (ulong_t)hashString(&segment[1]); + + startHash = 0; + for (j = 1; j < segmentLength; j++) { + startHash = (ulong_t)segment[j-1] + + (startHash << 6) + (startHash << 16) - startHash; + TM_BEGIN(); + status = TMTABLE_INSERT(startHashToConstructEntryTables[j], + (ulong_t)startHash, + (void*)constructEntryPtr ); + TM_END(); + assert(status); + } + + /* + * For looking up construct entries quickly + */ + startHash = (ulong_t)segment[j-1] + + (startHash << 6) + (startHash << 16) - startHash; + TM_BEGIN(); + status = TMTABLE_INSERT(hashToConstructEntryTable, + (ulong_t)startHash, + (void*)constructEntryPtr); + TM_END(); + assert(status); + } + } + + thread_barrier_wait(); + + /* + * Step 2b: Match ends to starts by using hash-based string comparison. + */ + for (substringLength = segmentLength-1; substringLength > 0; substringLength--) { + + table_t* startHashToConstructEntryTablePtr = + startHashToConstructEntryTables[substringLength]; + list_t** buckets = startHashToConstructEntryTablePtr->buckets; + long numBucket = startHashToConstructEntryTablePtr->numBucket; + + long index_start; + long index_stop; + +#if defined(HTM) || defined(STM) + { + /* Choose disjoint segments [index_start,index_stop) for each thread */ + long partitionSize = (numUniqueSegment + numThread/2) / numThread; /* with rounding */ + index_start = threadId * partitionSize; + if (threadId == (numThread - 1)) { + index_stop = numUniqueSegment; + } else { + index_stop = index_start + partitionSize; + } + } +#else /* !(HTM || STM) */ + index_start = 0; + index_stop = numUniqueSegment; +#endif /* !(HTM || STM) */ + + /* Iterating over disjoint itervals in the range [0, numUniqueSegment) */ + for (entryIndex = index_start; + entryIndex < index_stop; + entryIndex += endInfoEntries[entryIndex].jumpToNext) + { + if (!endInfoEntries[entryIndex].isEnd) { + continue; + } + + /* ConstructEntries[entryIndex] is local data */ + constructEntry_t* endConstructEntryPtr = + &constructEntries[entryIndex]; + char* endSegment = endConstructEntryPtr->segment; + ulong_t endHash = endConstructEntryPtr->endHash; + + list_t* chainPtr = buckets[endHash % numBucket]; /* buckets: constant data */ + list_iter_t it; + list_iter_reset(&it, chainPtr); + + /* Linked list at chainPtr is constant */ + while (list_iter_hasNext(&it, chainPtr)) { + + constructEntry_t* startConstructEntryPtr = + (constructEntry_t*)list_iter_next(&it, chainPtr); + char* startSegment = startConstructEntryPtr->segment; + long newLength = 0; + + /* endConstructEntryPtr is local except for properties startPtr/endPtr/length */ + TM_BEGIN(); + + /* Check if matches */ + if (TM_SHARED_READ(startConstructEntryPtr->isStart) && + (TM_SHARED_READ_P(endConstructEntryPtr->startPtr) != startConstructEntryPtr) && + (strncmp(startSegment, + &endSegment[segmentLength - substringLength], + substringLength) == 0)) + { + TM_SHARED_WRITE(startConstructEntryPtr->isStart, FALSE); + + constructEntry_t* startConstructEntry_endPtr; + constructEntry_t* endConstructEntry_startPtr; + + /* Update endInfo (appended something so no longer end) */ + TM_LOCAL_WRITE(endInfoEntries[entryIndex].isEnd, FALSE); + + /* Update segment chain construct info */ + startConstructEntry_endPtr = + (constructEntry_t*)TM_SHARED_READ_P(startConstructEntryPtr->endPtr); + endConstructEntry_startPtr = + (constructEntry_t*)TM_SHARED_READ_P(endConstructEntryPtr->startPtr); + + assert(startConstructEntry_endPtr); + assert(endConstructEntry_startPtr); + TM_SHARED_WRITE_P(startConstructEntry_endPtr->startPtr, + endConstructEntry_startPtr); + TM_LOCAL_WRITE_P(endConstructEntryPtr->nextPtr, + startConstructEntryPtr); + TM_SHARED_WRITE_P(endConstructEntry_startPtr->endPtr, + startConstructEntry_endPtr); + TM_SHARED_WRITE(endConstructEntryPtr->overlap, substringLength); + newLength = (long)TM_SHARED_READ(endConstructEntry_startPtr->length) + + (long)TM_SHARED_READ(startConstructEntryPtr->length) - + substringLength; + TM_SHARED_WRITE(endConstructEntry_startPtr->length, newLength); + } /* if (matched) */ + + TM_END(); + + if (!endInfoEntries[entryIndex].isEnd) { /* if there was a match */ + break; + } + } /* iterate over chain */ + + } /* for (endIndex < numUniqueSegment) */ + + thread_barrier_wait(); + + /* + * Step 2c: Update jump values and hashes + * + * endHash entries of all remaining ends are updated to the next + * substringLength. Additionally jumpToNext entries are updated such + * that they allow to skip non-end entries. Currently this is sequential + * because parallelization did not perform better. +. */ + + if (threadId == 0) { + if (substringLength > 1) { + long index = segmentLength - substringLength + 1; + /* initialization if j and i: with i being the next end after j=0 */ + for (i = 1; !endInfoEntries[i].isEnd; i+=endInfoEntries[i].jumpToNext) { + /* find first non-null */ + } + /* entry 0 is handled seperately from the loop below */ + endInfoEntries[0].jumpToNext = i; + if (endInfoEntries[0].isEnd) { + constructEntry_t* constructEntryPtr = &constructEntries[0]; + char* segment = constructEntryPtr->segment; + constructEntryPtr->endHash = (ulong_t)hashString(&segment[index]); + } + /* Continue scanning (do not reset i) */ + for (j = 0; i < numUniqueSegment; i+=endInfoEntries[i].jumpToNext) { + if (endInfoEntries[i].isEnd) { + constructEntry_t* constructEntryPtr = &constructEntries[i]; + char* segment = constructEntryPtr->segment; + constructEntryPtr->endHash = (ulong_t)hashString(&segment[index]); + endInfoEntries[j].jumpToNext = MAX(1, (i - j)); + j = i; + } + } + endInfoEntries[j].jumpToNext = i - j; + } + } + + thread_barrier_wait(); + + } /* for (substringLength > 0) */ + + + thread_barrier_wait(); + + /* + * Step 3: Build sequence string + */ + if (threadId == 0) { + + long totalLength = 0; + + for (i = 0; i < numUniqueSegment; i++) { + constructEntry_t* constructEntryPtr = &constructEntries[i]; + if (constructEntryPtr->isStart) { + totalLength += constructEntryPtr->length; + } + } + + sequencerPtr->sequence = (char*)P_MALLOC((totalLength+1) * sizeof(char)); + char* sequence = sequencerPtr->sequence; + assert(sequence); + + char* copyPtr = sequence; + long sequenceLength = 0; + + for (i = 0; i < numUniqueSegment; i++) { + constructEntry_t* constructEntryPtr = &constructEntries[i]; + /* If there are several start segments, we append in arbitrary order */ + if (constructEntryPtr->isStart) { + long newSequenceLength = sequenceLength + constructEntryPtr->length; + assert( newSequenceLength <= totalLength ); + copyPtr = sequence + sequenceLength; + sequenceLength = newSequenceLength; + do { + long numChar = segmentLength - constructEntryPtr->overlap; + if ((copyPtr + numChar) > (sequence + newSequenceLength)) { + TM_PRINT0("ERROR: sequence length != actual length\n"); + break; + } + memcpy(copyPtr, + constructEntryPtr->segment, + (numChar * sizeof(char))); + copyPtr += numChar; + } while ((constructEntryPtr = constructEntryPtr->nextPtr) != NULL); + assert(copyPtr <= (sequence + sequenceLength)); + } + } + + assert(sequence != NULL); + sequence[sequenceLength] = '\0'; + } + + TM_THREAD_EXIT(); + + } + + + private class endInfoEntry { + boolean isEnd; + long jumpToNext; + } + + private class constructEntry { + boolean isStart; + String segment; + long endHash; + constructEntry startPtr; + constructEntry nextPtr; + constructEntry endPtr; + long overlap; + long length; + } + + private class sequencer_run_arg { + Sequencer sequencerPtr; + Segments segmentsPtr; + long preAllocLength; + String returnSequence; /* variable stores return value */ + } + /* ============================================================================= + * hashString + * -- uses sdbm hash function + * ============================================================================= + */ + static long hashString (String str) + { + long hash = 0; + long c; + + /* Note: Do not change this hashing scheme */ + while ((c = str++) != '\0') { + hash = c + (hash << 6) + (hash << 16) - hash; + } + + return (long)hash; + } + + + /* ============================================================================= + * hashSegment + * -- For hashtable + * ============================================================================= + */ + static long hashSegment (string keyPtr) + { + return (long)hash_sdbm(keyPtr); /* can be any "good" hash function */ + } + + + /* ============================================================================= + * compareSegment + * -- For hashtable + * ============================================================================= + */ + static long compareSegment (pair_t* a, pair_t* b) + { + return strcmp((char*)(a->firstPtr), (char*)(b->firstPtr)); + } + +} diff --git a/Robust/src/Benchmarks/SingleTM/genome/java/Table.java b/Robust/src/Benchmarks/SingleTM/genome/java/Table.java new file mode 100644 index 00000000..83893a87 --- /dev/null +++ b/Robust/src/Benchmarks/SingleTM/genome/java/Table.java @@ -0,0 +1,57 @@ +public class Table { + + LinkedList buckets[]; + long numBucket; + + + /* ============================================================================= + * table_alloc + * -- Returns NULL on failure + * ============================================================================= + */ + Table (long myNumBucket) { + + long i; + + buckets = new LinkedList[myNumBucket]; + + numBucket = myNumBucket; + + } + + + /* ============================================================================= + * table_insert + * -- Returns TRUE if successful, else FALSE + * ============================================================================= + */ + boolean table_insert (long hash, void* dataPtr) { + long i = hash % numBucket; + + if(buckets[i].indexOf(dataPtr) != -1) { + return FALSE; + } + + buckets[i].add(dataPtr); + + return TRUE; + } + + /* ============================================================================= + * table_remove + * -- Returns TRUE if successful, else FALSE + * ============================================================================= + */ + boolean table_remove (long hash, void* dataPtr) { + + long i = hash % numBucket; + + if (!buckets[i].remove(dataPtr) { + return FALSE; + } + + return TRUE; + + } + +} diff --git a/Robust/src/Benchmarks/SingleTM/genome/java/Table.java~ b/Robust/src/Benchmarks/SingleTM/genome/java/Table.java~ new file mode 100644 index 00000000..28b2ed5f --- /dev/null +++ b/Robust/src/Benchmarks/SingleTM/genome/java/Table.java~ @@ -0,0 +1,57 @@ +public class Table { + + LinkedList buckets[]; + long numBucket; + + + /* ============================================================================= + * table_alloc + * -- Returns NULL on failure + * ============================================================================= + */ + Table (long myNumBucket) { + + long i; + + buckets = new LinkedList[myNumBucket]; + + numBucket = myNumBucket; + + } + + + /* ============================================================================= + * table_insert + * -- Returns TRUE if successful, else FALSE + * ============================================================================= + */ + boolean table_insert (long hash, void* dataPtr) { + long i = hash % numBucket; + + if(buckets[i].indexOf(dataPtr) != -1) { + return FALSE; + } + + buckets[i].add(dataPtr); + + return TRUE; + } + + /* ============================================================================= + * table_remove + * -- Returns TRUE if successful, else FALSE + * ============================================================================= + */ + boolean table_remove (long hash, void* dataPtr) { + + long i = hash % numBucket; + + if (!list_remove(tablePtr->buckets[i], dataPtr)) { + return FALSE; + } + + return TRUE; + + } + +} diff --git a/Robust/src/Benchmarks/SingleTM/genome/java/genome.java~ b/Robust/src/Benchmarks/SingleTM/genome/java/genome.java~ new file mode 100644 index 00000000..8b137891 --- /dev/null +++ b/Robust/src/Benchmarks/SingleTM/genome/java/genome.java~ @@ -0,0 +1 @@ + diff --git a/Robust/src/Benchmarks/SingleTM/genome/nucleotide.h b/Robust/src/Benchmarks/SingleTM/genome/nucleotide.h new file mode 100644 index 00000000..c7b5ed4e --- /dev/null +++ b/Robust/src/Benchmarks/SingleTM/genome/nucleotide.h @@ -0,0 +1,93 @@ +/* ============================================================================= + * + * nucleotide.h + * + * ============================================================================= + * + * Copyright (C) Stanford University, 2006. All Rights Reserved. + * Author: Chi Cao Minh + * + * ============================================================================= + * + * For the license of bayes/sort.h and bayes/sort.c, please see the header + * of the files. + * + * ------------------------------------------------------------------------ + * + * For the license of kmeans, please see kmeans/LICENSE.kmeans + * + * ------------------------------------------------------------------------ + * + * For the license of ssca2, please see ssca2/COPYRIGHT + * + * ------------------------------------------------------------------------ + * + * For the license of lib/mt19937ar.c and lib/mt19937ar.h, please see the + * header of the files. + * + * ------------------------------------------------------------------------ + * + * For the license of lib/rbtree.h and lib/rbtree.c, please see + * lib/LEGALNOTICE.rbtree and lib/LICENSE.rbtree + * + * ------------------------------------------------------------------------ + * + * Unless otherwise noted, the following license applies to STAMP files: + * + * Copyright (c) 2007, Stanford University + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * * Neither the name of Stanford University nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY STANFORD UNIVERSITY ``AS IS'' AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL STANFORD UNIVERSITY BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF + * THE POSSIBILITY OF SUCH DAMAGE. + * + * ============================================================================= + */ + + +#ifndef NUCLEOTIDE_H +#define NUCLEOTIDE_H 1 + + +typedef enum nucleotide_type { + NUCLEOTIDE_ADENINE = 'a', + NUCLEOTIDE_CYTOSINE = 'c', + NUCLEOTIDE_GUANINE = 'g', + NUCLEOTIDE_THYMINE = 't', + NUCLEOTIDE_NUM_TYPE = 4 +} nucleotide_type_t; + + +#endif /* NUCLEOTIDE_H */ + + +/* ============================================================================= + * + * End of nucleotide.h + * + * ============================================================================= + */ diff --git a/Robust/src/Benchmarks/SingleTM/genome/segments.c b/Robust/src/Benchmarks/SingleTM/genome/segments.c new file mode 100644 index 00000000..e89271d9 --- /dev/null +++ b/Robust/src/Benchmarks/SingleTM/genome/segments.c @@ -0,0 +1,318 @@ +/* ============================================================================= + * + * segments.c + * -- Create random segments from random gene + * + * ============================================================================= + * + * Copyright (C) Stanford University, 2006. All Rights Reserved. + * Author: Chi Cao Minh + * + * ============================================================================= + * + * For the license of bayes/sort.h and bayes/sort.c, please see the header + * of the files. + * + * ------------------------------------------------------------------------ + * + * For the license of kmeans, please see kmeans/LICENSE.kmeans + * + * ------------------------------------------------------------------------ + * + * For the license of ssca2, please see ssca2/COPYRIGHT + * + * ------------------------------------------------------------------------ + * + * For the license of lib/mt19937ar.c and lib/mt19937ar.h, please see the + * header of the files. + * + * ------------------------------------------------------------------------ + * + * For the license of lib/rbtree.h and lib/rbtree.c, please see + * lib/LEGALNOTICE.rbtree and lib/LICENSE.rbtree + * + * ------------------------------------------------------------------------ + * + * Unless otherwise noted, the following license applies to STAMP files: + * + * Copyright (c) 2007, Stanford University + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * * Neither the name of Stanford University nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY STANFORD UNIVERSITY ``AS IS'' AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL STANFORD UNIVERSITY BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF + * THE POSSIBILITY OF SUCH DAMAGE. + * + * ============================================================================= + */ + + +#include +#include +#include +#include "gene.h" +#include "random.h" +#include "segments.h" +#include "utility.h" +#include "vector.h" + + +/* ============================================================================= + * segments_alloc + * -- Does almost all the memory allocation for random segments + * -- The actual number of segments created by 'segments_create' may be larger + * than 'minNum' to ensure the segments overlap and cover the entire gene + * -- Returns NULL on failure + * ============================================================================= + */ +segments_t* +segments_alloc (long length, long minNum) +{ + segments_t* segmentsPtr; + long i; + char* string; + + segmentsPtr = (segments_t*)malloc(sizeof(segments_t)); + if (segmentsPtr == NULL) { + return NULL; + } + + /* Preallocate for the min number of segments we will need */ + segmentsPtr->strings = (char**)malloc(minNum * sizeof(char*)); + if (segmentsPtr->strings == NULL) { + return NULL; + } + + string = (char*)malloc(minNum * (length+1) * sizeof(char)); + if (string == NULL) { + return NULL; + } + for (i = 0; i < minNum; i++) { + segmentsPtr->strings[i] = &string[i * (length+1)]; + segmentsPtr->strings[i][length] = '\0'; + } + segmentsPtr->minNum = minNum; + segmentsPtr->length = length; + + segmentsPtr->contentsPtr = vector_alloc(minNum); + if (segmentsPtr->contentsPtr == NULL) { + return NULL; + } + + return segmentsPtr; +} + + +/* ============================================================================= + * segments_create + * -- Populates 'contentsPtr' + * ============================================================================= + */ +void +segments_create (segments_t* segmentsPtr, gene_t* genePtr, random_t* randomPtr) +{ + vector_t* segmentsContentsPtr; + char** strings; + long segmentLength; + long minNumSegment; + char* geneString; + long geneLength; + bitmap_t* startBitmapPtr; + long numStart; + long i; + long maxZeroRunLength; + + assert(segmentsPtr != NULL); + assert(genePtr != NULL); + assert(randomPtr != NULL); + + segmentsContentsPtr = segmentsPtr->contentsPtr; + strings = segmentsPtr->strings; + segmentLength = segmentsPtr->length; + minNumSegment = segmentsPtr->minNum; + + geneString = genePtr->contents; + geneLength = genePtr->length; + startBitmapPtr = genePtr->startBitmapPtr; + numStart = geneLength - segmentLength + 1; + + /* Pick some random segments to start */ + for (i = 0; i < minNumSegment; i++) { + long j = (long)(random_generate(randomPtr) % numStart); + bool_t status = bitmap_set(startBitmapPtr, j); + assert(status); + memcpy(strings[i], &(geneString[j]), segmentLength * sizeof(char)); + status = vector_pushBack(segmentsContentsPtr, (void*)strings[i]); + assert(status); + } + + /* Make sure segment covers start */ + i = 0; + if (!bitmap_isSet(startBitmapPtr, i)) { + char* string = (char*)malloc((segmentLength+1) * sizeof(char)); + string[segmentLength] = '\0'; + memcpy(string, &(geneString[i]), segmentLength * sizeof(char)); + bool_t status = vector_pushBack(segmentsContentsPtr, (void*)string); + assert(status); + status = bitmap_set(startBitmapPtr, i); + assert(status); + } + + /* Add extra segments to fill holes and ensure overlap */ + maxZeroRunLength = segmentLength - 1; + for (i = 0; i < numStart; i++) { + long i_stop = MIN((i+maxZeroRunLength), numStart); + for ( /* continue */; i < i_stop; i++) { + if (bitmap_isSet(startBitmapPtr, i)) { + break; + } + } + if (i == i_stop) { + /* Found big enough hole */ + char* string = (char*)malloc((segmentLength+1) * sizeof(char)); + string[segmentLength] = '\0'; + i = i - 1; + memcpy(string, &(geneString[i]), segmentLength * sizeof(char)); + bool_t status = vector_pushBack(segmentsContentsPtr, (void*)string); + assert(status); + status = bitmap_set(startBitmapPtr, i); + assert(status); + } + } +} + + +/* ============================================================================= + * segments_free + * ============================================================================= + */ +void +segments_free (segments_t* segmentsPtr) +{ + free(vector_at(segmentsPtr->contentsPtr, 0)); + vector_free(segmentsPtr->contentsPtr); + free(segmentsPtr->strings); + free(segmentsPtr); +} + + +/* ============================================================================= + * TEST_SEGMENTS + * ============================================================================= + */ +#ifdef TEST_SEGMENTS + + +#include +#include +#include +#include "types.h" + + +static void +tester (long geneLength, long segmentLength, long minNumSegment, bool_t doPrint) +{ + gene_t* genePtr; + segments_t* segmentsPtr; + random_t* randomPtr; + bitmap_t* startBitmapPtr; + long i; + long j; + + genePtr = gene_alloc(geneLength); + segmentsPtr = segments_alloc(segmentLength, minNumSegment); + randomPtr = random_alloc(); + startBitmapPtr = bitmap_alloc(geneLength); + + random_seed(randomPtr, 0); + gene_create(genePtr, randomPtr); + random_seed(randomPtr, 0); + segments_create(segmentsPtr, genePtr, randomPtr); + + assert(segmentsPtr->minNum == minNumSegment); + assert(vector_getSize(segmentsPtr->contentsPtr) >= minNumSegment); + + if (doPrint) { + printf("Gene = %s\n", genePtr->contents); + } + + /* Check that each segment occurs in gene */ + for (i = 0; i < vector_getSize(segmentsPtr->contentsPtr); i++) { + char *charPtr = strstr(genePtr->contents, + (char*)vector_at(segmentsPtr->contentsPtr, i)); + assert(charPtr != NULL); + j = charPtr - genePtr->contents; + bitmap_set(startBitmapPtr, j); + if (doPrint) { + printf("Segment %li (@%li) = %s\n", + i, j, (char*)vector_at(segmentsPtr->contentsPtr, i)); + } + } + + /* Check that there is complete overlap */ + assert(bitmap_isSet(startBitmapPtr, 0)); + for (i = 0, j = 0; i < geneLength; i++ ) { + if (bitmap_isSet(startBitmapPtr, i)) { + assert((i-j-1) < segmentLength); + j = i; + } + } + + gene_free(genePtr); + segments_free(segmentsPtr); + random_free(randomPtr); + bitmap_free(startBitmapPtr); +} + + +int +main () +{ + bool_t status = memory_init(1, 4, 2) + assert(status); + + puts("Starting..."); + + tester(10, 4, 20, TRUE); + tester(20, 5, 1, TRUE); + tester(100, 10, 1000, FALSE); + tester(100, 10, 1, FALSE); + + puts("All tests passed."); + + return 0; +} + + +#endif /* TEST_SEGMENTS */ + + +/* ============================================================================= + * + * End of segments.c + * + * ============================================================================= + */ diff --git a/Robust/src/Benchmarks/SingleTM/genome/segments.h b/Robust/src/Benchmarks/SingleTM/genome/segments.h new file mode 100644 index 00000000..bf8473f8 --- /dev/null +++ b/Robust/src/Benchmarks/SingleTM/genome/segments.h @@ -0,0 +1,128 @@ +/* ============================================================================= + * + * segments.h + * -- Create random segments from random gene + * + * ============================================================================= + * + * Copyright (C) Stanford University, 2006. All Rights Reserved. + * Author: Chi Cao Minh + * + * ============================================================================= + * + * For the license of bayes/sort.h and bayes/sort.c, please see the header + * of the files. + * + * ------------------------------------------------------------------------ + * + * For the license of kmeans, please see kmeans/LICENSE.kmeans + * + * ------------------------------------------------------------------------ + * + * For the license of ssca2, please see ssca2/COPYRIGHT + * + * ------------------------------------------------------------------------ + * + * For the license of lib/mt19937ar.c and lib/mt19937ar.h, please see the + * header of the files. + * + * ------------------------------------------------------------------------ + * + * For the license of lib/rbtree.h and lib/rbtree.c, please see + * lib/LEGALNOTICE.rbtree and lib/LICENSE.rbtree + * + * ------------------------------------------------------------------------ + * + * Unless otherwise noted, the following license applies to STAMP files: + * + * Copyright (c) 2007, Stanford University + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * * Neither the name of Stanford University nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY STANFORD UNIVERSITY ``AS IS'' AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL STANFORD UNIVERSITY BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF + * THE POSSIBILITY OF SUCH DAMAGE. + * + * ============================================================================= + */ + + +#ifndef SEGMENTS_H +#define SEGMENTS_H 1 + + +#include "gene.h" +#include "random.h" +#include "vector.h" + + +typedef struct segments { + long length; + long minNum; + vector_t* contentsPtr; +/* private: */ + char** strings; +} segments_t; + + +/* ============================================================================= + * segments_alloc + * -- Does almost all the memory allocation for random segments + * -- The actual number of segments created by 'segments_create' may be larger + * than 'minNum' to ensure the segments overlap and cover the entire gene + * -- Returns NULL on failure + * ============================================================================= + */ +segments_t* +segments_alloc (long length, long minNum); + + +/* ============================================================================= + * segments_create + * -- Populates 'contentsPtr' + * ============================================================================= + */ +void +segments_create (segments_t* segmentsPtr, gene_t* genePtr, random_t* randomPtr); + + +/* ============================================================================= + * segments_free + * ============================================================================= + */ +void +segments_free (segments_t* segmentsPtr); + + +#endif /* SEGMENTS_H */ + + +/* ============================================================================= + * + * End of segments.h + * + * ============================================================================= + */ diff --git a/Robust/src/Benchmarks/SingleTM/genome/segments.o b/Robust/src/Benchmarks/SingleTM/genome/segments.o new file mode 100644 index 0000000000000000000000000000000000000000..03bc11b348b154af2c8e406664b349af5fe7fe6f GIT binary patch literal 10056 zcma)B3v^WFo&WCK2{V}tNgyFSl_-&iNJ1c51cC?zNhKIb!b6F}B)LguNoKM$cX)Wj z2O;8ggaudY`qptQ;jW|6HWc6OS7%P zLrW_B6lE6&GyaN`XV0BG=b}fHT^x3$nbu(c>!mlho}%gQoi9wLH{z{cg^2UBb-`>) zcwm3g_5q(#1Md`VUkl7O6b~FJ+Wu{l%YxZkgPDe-*=6BO!?A2IyU?F$IG(BdFuTZ~ z9hs>++5eg`?Tt*!>1@k~1Ml1(ul{`JMwM+T&XhXURlk#&U-3oybmrYmbA?|Q%ye&| z`&q=RJDDy0akk;OaWsRT!6~!6BB-shEyuD*>wi8IuAnaGnt*HnL1SL}!}Npha3Duc z|2BuG?)1R^+po*k9k2d8+j6}Bq=7Osb!Rdy?`0d#?3_?Iul4lpX14Y8)t}yx|GOy& zclE#7mu75~kc(uWqBwo}j(_fdeg4h2L|PA|KhD;@*Z;BMjx8c*4jl9sBi%{#E|{56 zVVud;it01#5HLJgS~p4`nk4-Qx)A1^0E2HhsAu?)zhV_wXDsTD_wUc8%^X0#4*E?D z^GRf5+T7S)An9l%y}&pP9R2FtIdAe8za}~6(`&Z(Ys|bhPyPiq4-B>8y3~F3#<_o} zO~Hk1zCF~Y_Chv?huY-E)tl=dzs6>#J(>HZ|MVElNHL5u=`S;_pJle5l@*scm>yC6 ztIW}C`pazVXW6Z1GpAb*aE`*S9{0IRWnh11Y1lrB{lW?ABnW^q&4#jf4Kt%4|6^uOXcN9lR)C>d!0~^vo;`rtdm+E4H^X zMi`eBmK2zU;|oU^BaPx=O8Lr^Sva>~UO|0{Qf7rJC|Cf!Qhp(WO657EQp1X%Rw_WC zd9cJV3kwS9ZGg=mo(nZ6q*O@Qy!sNd1#Tjx!iG^_LXY8>sQQvBge=sN^4v&8a1A;| z(Y1J#F(vGHjL3tBQX{ovo>C>1#x-H515?86)52j4T$-0F#fJc+JS_TLRx_vtJ9>~+ zY77`j?SpP?fzhHPjvJIKHNF5NITHJ30$uA%YQoHNk++umlEG>&o~(}@O*CS z6Py4bhTHhqRLV$#<4b^Tir(fhm`R=U|^K-sAm14Pso-D8w^=U8W=5XI8=Zk z3ycxAIK=J+#tK^+%90%??3hqHLyZ@9La2m!CkR^}x`M_R3tJI-lZhq@J2jLdTQ2Ms zp*LxKsgVb%Z_>=r#f)5G6lk_4bc*a`>Cv3fG8$hl?EKJvvR4>)!N@mhVQ3=Dm}xB6 z?2=HJiK>m8G`lpkn4xAFBXs2JLW}5om2rt?mxb2T_Zs6~ZM-~mCw-S04{NqLw1aHD zuxmoQ$bM7Ub)g5yUN7wW(4%CR8<%O{j!+{Lt&p0#L;pZ+qcH{Go7AHUo}&7N;7^c0 z9C(?-kl#X+ea?ue{6ZSM;tYsCe;>L1&J1%oyhYw0p!Z`)$nFe(5Co-M6I%KWS2{%% zwnBI~Ke#HvOk2SOSAPqnZ;~qNwN-G(`pd^prH9cwke6fr}xO;kSKwJNmQ-89>%TSGG^j-JO)C|vs)<2(eixM1a7 zjKg{gn%sJt5vQQpjl*#+XrUS6f{pP$N#7ni?$p-omvN8L2&>ybUIF|jUTvea^$uFEfoK%2B+A%9&0(@n zBD}Gq5$qgLWpl}9SZAMRS;4nh=x(x4!o$e2PaMj!4r=cu`*X5fr^Zh9;tbf)6-=~? z+A_|D@i**RFVQ?r|ztHF+mDPs>A-fBm`Pt*Iz>g)E)I9|s6l`7T$j<*a8p&W>b$y-$nO#SA_1HS}rN z9`16(n79gE9d@6?sP9ALQzw|q_+#O4eClsIkQ!C#RI;ik)>hTk-d+`}nRC^Qo>)A+ zc}7<}T~$*#t8#W#EZ*Le?y!`$6sD>zW~WqTB|V2IluB7$y;j^#RkpLzl-ceD;pRyUlQCfB&S53HS0WtLUWHakA7`CvxvtYEs~ z=)8Fgmfc-DuXbktj9Om+GvgUQmu$3?<(Jf!Po26k5$h)uisNtru`^T`P^9dr zolfN@C(@p@qPB%WD#nAm={Z9gw*|v~|2>!}ZZ5ZRLtR@K9Plj~p0}jmR1-wOm(3NJ zGFP{>Kksfo&Nx@kh5wYtw`qq-3+;^*SOm782s6?_B6ImvItb8>Ic~&5TcW=Iz?R4t z-TAg%+IEj3?!sfJM#5pN2AUF2WBbd}>dSC`pQmPRV<8$xHfX@z;%~N53{~VxC7G(yLvsMU7p6ltXR;-0P4B0Y@G3mjKKs3t^dSoW3l7747LswCezT^*Ev6BaH>P?Ku!5Frs(Dh?DBJTF4f1v{4-gmD9>V^+3+t zVmwPJlXkv+hB~q5>Nww?x;yc>6XwQ=L=v5y5nHuK`=aeJdy9(H-w?rjxg*kNCsm}q zI~t4Y7k!hRjK#ZDDt4V(!DC4?p>WocIb%E zM%tn&E9amqDgy^zA3QVZl#O8LlODwG=|QW3kB0+cvF_Gs=5=sR#mjq>ev)bc2p&;lod_3 zcUP@Uw53yaRVvwDwaALMclSn<8&XwG80sFYxuFV2Ec{gNNYzupu$U#9TBrl}mAD!* zh`rIxH(ANV%5>a2Vna;Q9C`_~DH*dZXTDQ<8ZpO8PipxPA0|yjH(Jh2I+Kmz!qVR$ zV>e4hdK0*&p{7LIma>(z9-5r{QEuFDH)FSy)nnewjRq3hxOaUDc5=#NXW1P za>a2SU{!HZ>fo_R%1-pDNZi_tIbxuzYNTYnr}P%c4WnLQk-lh0HEaPGJ;H1UY8<#y zMbhzf%7WG%68GXH_bF#_NSd~2`-XI%Gegd;cF@gM*R5zNUtF%Q)a6r`SZ%Rr+~HB~zr^030*LkSQ)Rtb18PHBT*zHnDtEbZDFjRI#?Wn43OX05GVYQ{Z zBGIb|7SN7HjM8!#^bkZx4GmZ2wa-FFY$$z zr=#0k9lsiS`_X+V;vpvcL37r}x>n+GeL$-Jz#;xakH95YKRn(;^KMT7)64IELEse)ppPHf+$CUN) zUgFkwH)wCXo+9LRgLriOkHc$sTZvNFL*_PD$2+h$?@Z+7crY(Q=ko3a?fQUJhY+uv zgfv(81bA<}If%z`VZ0G|+{TA_dlaS`>4uU7mv0&R&iXS)5>o4{Hg2(lt z-5w;IL_(UY`z3gnrs@S2=4q~uwYqDbYTA8t0Xy2eYk=zKE<%4H;O{)>lI}12&oS}F z+m8+X7G!R7^SZo?Ub$a=a?X_#hyIgG-kX8EXP~q_Hk+rJxwnZUH1*668kj1i*B&M8 zgQ4($il>=>#^-L(+R9W|?4D-o6*VX@^@{NF9I?S>DonPgnX1ggv45lVdyK+mct)ba z*&Ykl%s=JaMt+gY0Libw(};)P_vz35?>6e=E(0Xb{p>dKce)Ia{O=4c+DhM3gw^!J(D>u6ffw5sf@i6}7{7R9uhM@q5&l;a;om@nKmQM)e=iaKw%``(;lEw< z_lx`y!S9Ox`=bA;$bTmIy6E2&{V|dA|2F11Df%;_=hmh?AQ%QRe<^v?r+=4*e!A#q zihhphmx=ra!Di8~6Mc`!`S%m^Y!>~4M2ycr3I40#XuMi{ zu*~y;;BN%~An50MfWAcVQo(A$g@QK--Xf^iFZ^y3p8r@f&clLx1@$_GT>mlzd|Twd z5Y9^yMiAOVRu~g9|`|^;s0CsuY?a`?bCiZ5&ak~`~=}A z3qM`>D}|pc{1V~og>MpmjqvS)y&_Kvf1B_b!CfMMh=>c^4}^bF^!r5qy2#%W`MV-N zCi343ej@rWh#1E|3YKBRGyX&(`g^%x4H4roSNJ+2-cM_UZzm#7m*55>>}}ECE_}c6 zJB7bb_(z4`EBLI)-xfS3_+Q+&$iwTMfoltYKqFrx{2bw%g +#include +#include +#include "hash.h" +#include "hashtable.h" +#include "segments.h" +#include "sequencer.h" +#include "table.h" +#include "thread.h" +#include "utility.h" +#include "vector.h" +#include "types.h" + + +struct endInfoEntry { + bool_t isEnd; + long jumpToNext; +}; + +struct constructEntry { + bool_t isStart; + char* segment; + ulong_t endHash; + struct constructEntry* startPtr; + struct constructEntry* nextPtr; + struct constructEntry* endPtr; + long overlap; + long length; +}; + + +/* ============================================================================= + * hashString + * -- uses sdbm hash function + * ============================================================================= + */ +static ulong_t +hashString (char* str) +{ + ulong_t hash = 0; + long c; + + /* Note: Do not change this hashing scheme */ + while ((c = *str++) != '\0') { + hash = c + (hash << 6) + (hash << 16) - hash; + } + + return (ulong_t)hash; +} + + +/* ============================================================================= + * hashSegment + * -- For hashtable + * ============================================================================= + */ +static ulong_t +hashSegment (const void* keyPtr) +{ + return (ulong_t)hash_sdbm((char*)keyPtr); /* can be any "good" hash function */ +} + + +/* ============================================================================= + * compareSegment + * -- For hashtable + * ============================================================================= + */ +static long +compareSegment (const pair_t* a, const pair_t* b) +{ + return strcmp((char*)(a->firstPtr), (char*)(b->firstPtr)); +} + + +/* ============================================================================= + * sequencer_alloc + * -- Returns NULL on failure + * ============================================================================= + */ +sequencer_t* +sequencer_alloc (long geneLength, long segmentLength, segments_t* segmentsPtr) +{ + sequencer_t* sequencerPtr; + long maxNumUniqueSegment = geneLength - segmentLength + 1; + long i; + + sequencerPtr = (sequencer_t*)malloc(sizeof(sequencer_t)); + if (sequencerPtr == NULL) { + return NULL; + } + + sequencerPtr->uniqueSegmentsPtr = + hashtable_alloc(geneLength, &hashSegment, &compareSegment, -1, -1); + if (sequencerPtr->uniqueSegmentsPtr == NULL) { + return NULL; + } + + /* For finding a matching entry */ + sequencerPtr->endInfoEntries = + (endInfoEntry_t*)malloc(maxNumUniqueSegment * sizeof(endInfoEntry_t)); + for (i = 0; i < maxNumUniqueSegment; i++) { + endInfoEntry_t* endInfoEntryPtr = &sequencerPtr->endInfoEntries[i]; + endInfoEntryPtr->isEnd = TRUE; + endInfoEntryPtr->jumpToNext = 1; + } + sequencerPtr->startHashToConstructEntryTables = + (table_t**)malloc(segmentLength * sizeof(table_t*)); + if (sequencerPtr->startHashToConstructEntryTables == NULL) { + return NULL; + } + for (i = 1; i < segmentLength; i++) { /* 0 is dummy entry */ + sequencerPtr->startHashToConstructEntryTables[i] = + table_alloc(geneLength, NULL); + if (sequencerPtr->startHashToConstructEntryTables[i] == NULL) { + return NULL; + } + } + sequencerPtr->segmentLength = segmentLength; + + /* For constructing sequence */ + sequencerPtr->constructEntries = + (constructEntry_t*)malloc(maxNumUniqueSegment * sizeof(constructEntry_t)); + if (sequencerPtr->constructEntries == NULL) { + return NULL; + } + for (i= 0; i < maxNumUniqueSegment; i++) { + constructEntry_t* constructEntryPtr = &sequencerPtr->constructEntries[i]; + constructEntryPtr->isStart = TRUE; + constructEntryPtr->segment = NULL; + constructEntryPtr->endHash = 0; + constructEntryPtr->startPtr = constructEntryPtr; + constructEntryPtr->nextPtr = NULL; + constructEntryPtr->endPtr = constructEntryPtr; + constructEntryPtr->overlap = 0; + constructEntryPtr->length = segmentLength; + } + sequencerPtr->hashToConstructEntryTable = table_alloc(geneLength, NULL); + if (sequencerPtr->hashToConstructEntryTable == NULL) { + return NULL; + } + + sequencerPtr->segmentsPtr = segmentsPtr; + + return sequencerPtr; +} + + +/* ============================================================================= + * sequencer_run + * ============================================================================= + */ +void +sequencer_run (void* argPtr) +{ + TM_THREAD_ENTER(); + + long threadId = thread_getId(); + + sequencer_t* sequencerPtr = (sequencer_t*)argPtr; + + hashtable_t* uniqueSegmentsPtr; + endInfoEntry_t* endInfoEntries; + table_t** startHashToConstructEntryTables; + constructEntry_t* constructEntries; + table_t* hashToConstructEntryTable; + + uniqueSegmentsPtr = sequencerPtr->uniqueSegmentsPtr; + endInfoEntries = sequencerPtr->endInfoEntries; + startHashToConstructEntryTables = sequencerPtr->startHashToConstructEntryTables; + constructEntries = sequencerPtr->constructEntries; + hashToConstructEntryTable = sequencerPtr->hashToConstructEntryTable; + + segments_t* segmentsPtr = sequencerPtr->segmentsPtr; + assert(segmentsPtr); + vector_t* segmentsContentsPtr = segmentsPtr->contentsPtr; + long numSegment = vector_getSize(segmentsContentsPtr); + long segmentLength = segmentsPtr->length; + + long i; + long j; + long i_start; + long i_stop; + long numUniqueSegment; + long substringLength; + long entryIndex; + + /* + * Step 1: Remove duplicate segments + */ +#if defined(HTM) || defined(STM) + long numThread = thread_getNumThread(); + { + /* Choose disjoint segments [i_start,i_stop) for each thread */ + long partitionSize = (numSegment + numThread/2) / numThread; /* with rounding */ + i_start = threadId * partitionSize; + if (threadId == (numThread - 1)) { + i_stop = numSegment; + } else { + i_stop = i_start + partitionSize; + } + } +#else /* !(HTM || STM) */ + i_start = 0; + i_stop = numSegment; +#endif /* !(HTM || STM) */ + for (i = i_start; i < i_stop; i+=CHUNK_STEP1) { + TM_BEGIN(); + { + long ii; + long ii_stop = MIN(i_stop, (i+CHUNK_STEP1)); + for (ii = i; ii < ii_stop; ii++) { + void* segment = vector_at(segmentsContentsPtr, ii); + TMHASHTABLE_INSERT(uniqueSegmentsPtr, + segment, + segment); + } /* ii */ + } + TM_END(); + } + + thread_barrier_wait(); + + /* + * Step 2a: Iterate over unique segments and compute hashes. + * + * For the gene "atcg", the hashes for the end would be: + * + * "t", "tc", and "tcg" + * + * And for the gene "tcgg", the hashes for the start would be: + * + * "t", "tc", and "tcg" + * + * The names are "end" and "start" because if a matching pair is found, + * they are the substring of the end part of the pair and the start + * part of the pair respectively. In the above example, "tcg" is the + * matching substring so: + * + * (end) (start) + * a[tcg] + [tcg]g = a[tcg]g (overlap = "tcg") + */ + + /* uniqueSegmentsPtr is constant now */ + numUniqueSegment = hashtable_getSize(uniqueSegmentsPtr); + entryIndex = 0; + +#if defined(HTM) || defined(STM) + { + /* Choose disjoint segments [i_start,i_stop) for each thread */ + long num = uniqueSegmentsPtr->numBucket; + long partitionSize = (num + numThread/2) / numThread; /* with rounding */ + i_start = threadId * partitionSize; + if (threadId == (numThread - 1)) { + i_stop = num; + } else { + i_stop = i_start + partitionSize; + } + } + { + /* Approximate disjoint segments of element allocation in constructEntries */ + long partitionSize = (numUniqueSegment + numThread/2) / numThread; /* with rounding */ + entryIndex = threadId * partitionSize; + } +#else /* !(HTM || STM) */ + i_start = 0; + i_stop = uniqueSegmentsPtr->numBucket; + entryIndex = 0; +#endif /* !(HTM || STM) */ + + for (i = i_start; i < i_stop; i++) { + + list_t* chainPtr = uniqueSegmentsPtr->buckets[i]; + list_iter_t it; + list_iter_reset(&it, chainPtr); + + while (list_iter_hasNext(&it, chainPtr)) { + + char* segment = + (char*)((pair_t*)list_iter_next(&it, chainPtr))->firstPtr; + constructEntry_t* constructEntryPtr; + long j; + ulong_t startHash; + bool_t status; + + /* Find an empty constructEntries entry */ + TM_BEGIN(); + while (((void*)TM_SHARED_READ_P(constructEntries[entryIndex].segment)) != NULL) { + entryIndex = (entryIndex + 1) % numUniqueSegment; /* look for empty */ + } + constructEntryPtr = &constructEntries[entryIndex]; + TM_SHARED_WRITE_P(constructEntryPtr->segment, segment); + TM_END(); + entryIndex = (entryIndex + 1) % numUniqueSegment; + + /* + * Save hashes (sdbm algorithm) of segment substrings + * + * endHashes will be computed for shorter substrings after matches + * have been made (in the next phase of the code). This will reduce + * the number of substrings for which hashes need to be computed. + * + * Since we can compute startHashes incrementally, we go ahead + * and compute all of them here. + */ + /* constructEntryPtr is local now */ + constructEntryPtr->endHash = (ulong_t)hashString(&segment[1]); + + startHash = 0; + for (j = 1; j < segmentLength; j++) { + startHash = (ulong_t)segment[j-1] + + (startHash << 6) + (startHash << 16) - startHash; + TM_BEGIN(); + status = TMTABLE_INSERT(startHashToConstructEntryTables[j], + (ulong_t)startHash, + (void*)constructEntryPtr ); + TM_END(); + assert(status); + } + + /* + * For looking up construct entries quickly + */ + startHash = (ulong_t)segment[j-1] + + (startHash << 6) + (startHash << 16) - startHash; + TM_BEGIN(); + status = TMTABLE_INSERT(hashToConstructEntryTable, + (ulong_t)startHash, + (void*)constructEntryPtr); + TM_END(); + assert(status); + } + } + + thread_barrier_wait(); + + /* + * Step 2b: Match ends to starts by using hash-based string comparison. + */ + for (substringLength = segmentLength-1; substringLength > 0; substringLength--) { + + table_t* startHashToConstructEntryTablePtr = + startHashToConstructEntryTables[substringLength]; + list_t** buckets = startHashToConstructEntryTablePtr->buckets; + long numBucket = startHashToConstructEntryTablePtr->numBucket; + + long index_start; + long index_stop; + +#if defined(HTM) || defined(STM) + { + /* Choose disjoint segments [index_start,index_stop) for each thread */ + long partitionSize = (numUniqueSegment + numThread/2) / numThread; /* with rounding */ + index_start = threadId * partitionSize; + if (threadId == (numThread - 1)) { + index_stop = numUniqueSegment; + } else { + index_stop = index_start + partitionSize; + } + } +#else /* !(HTM || STM) */ + index_start = 0; + index_stop = numUniqueSegment; +#endif /* !(HTM || STM) */ + + /* Iterating over disjoint itervals in the range [0, numUniqueSegment) */ + for (entryIndex = index_start; + entryIndex < index_stop; + entryIndex += endInfoEntries[entryIndex].jumpToNext) + { + if (!endInfoEntries[entryIndex].isEnd) { + continue; + } + + /* ConstructEntries[entryIndex] is local data */ + constructEntry_t* endConstructEntryPtr = + &constructEntries[entryIndex]; + char* endSegment = endConstructEntryPtr->segment; + ulong_t endHash = endConstructEntryPtr->endHash; + + list_t* chainPtr = buckets[endHash % numBucket]; /* buckets: constant data */ + list_iter_t it; + list_iter_reset(&it, chainPtr); + + /* Linked list at chainPtr is constant */ + while (list_iter_hasNext(&it, chainPtr)) { + + constructEntry_t* startConstructEntryPtr = + (constructEntry_t*)list_iter_next(&it, chainPtr); + char* startSegment = startConstructEntryPtr->segment; + long newLength = 0; + + /* endConstructEntryPtr is local except for properties startPtr/endPtr/length */ + TM_BEGIN(); + + /* Check if matches */ + if (TM_SHARED_READ(startConstructEntryPtr->isStart) && + (TM_SHARED_READ_P(endConstructEntryPtr->startPtr) != startConstructEntryPtr) && + (strncmp(startSegment, + &endSegment[segmentLength - substringLength], + substringLength) == 0)) + { + TM_SHARED_WRITE(startConstructEntryPtr->isStart, FALSE); + + constructEntry_t* startConstructEntry_endPtr; + constructEntry_t* endConstructEntry_startPtr; + + /* Update endInfo (appended something so no longer end) */ + TM_LOCAL_WRITE(endInfoEntries[entryIndex].isEnd, FALSE); + + /* Update segment chain construct info */ + startConstructEntry_endPtr = + (constructEntry_t*)TM_SHARED_READ_P(startConstructEntryPtr->endPtr); + endConstructEntry_startPtr = + (constructEntry_t*)TM_SHARED_READ_P(endConstructEntryPtr->startPtr); + + assert(startConstructEntry_endPtr); + assert(endConstructEntry_startPtr); + TM_SHARED_WRITE_P(startConstructEntry_endPtr->startPtr, + endConstructEntry_startPtr); + TM_LOCAL_WRITE_P(endConstructEntryPtr->nextPtr, + startConstructEntryPtr); + TM_SHARED_WRITE_P(endConstructEntry_startPtr->endPtr, + startConstructEntry_endPtr); + TM_SHARED_WRITE(endConstructEntryPtr->overlap, substringLength); + newLength = (long)TM_SHARED_READ(endConstructEntry_startPtr->length) + + (long)TM_SHARED_READ(startConstructEntryPtr->length) - + substringLength; + TM_SHARED_WRITE(endConstructEntry_startPtr->length, newLength); + } /* if (matched) */ + + TM_END(); + + if (!endInfoEntries[entryIndex].isEnd) { /* if there was a match */ + break; + } + } /* iterate over chain */ + + } /* for (endIndex < numUniqueSegment) */ + + thread_barrier_wait(); + + /* + * Step 2c: Update jump values and hashes + * + * endHash entries of all remaining ends are updated to the next + * substringLength. Additionally jumpToNext entries are updated such + * that they allow to skip non-end entries. Currently this is sequential + * because parallelization did not perform better. +. */ + + if (threadId == 0) { + if (substringLength > 1) { + long index = segmentLength - substringLength + 1; + /* initialization if j and i: with i being the next end after j=0 */ + for (i = 1; !endInfoEntries[i].isEnd; i+=endInfoEntries[i].jumpToNext) { + /* find first non-null */ + } + /* entry 0 is handled seperately from the loop below */ + endInfoEntries[0].jumpToNext = i; + if (endInfoEntries[0].isEnd) { + constructEntry_t* constructEntryPtr = &constructEntries[0]; + char* segment = constructEntryPtr->segment; + constructEntryPtr->endHash = (ulong_t)hashString(&segment[index]); + } + /* Continue scanning (do not reset i) */ + for (j = 0; i < numUniqueSegment; i+=endInfoEntries[i].jumpToNext) { + if (endInfoEntries[i].isEnd) { + constructEntry_t* constructEntryPtr = &constructEntries[i]; + char* segment = constructEntryPtr->segment; + constructEntryPtr->endHash = (ulong_t)hashString(&segment[index]); + endInfoEntries[j].jumpToNext = MAX(1, (i - j)); + j = i; + } + } + endInfoEntries[j].jumpToNext = i - j; + } + } + + thread_barrier_wait(); + + } /* for (substringLength > 0) */ + + + thread_barrier_wait(); + + /* + * Step 3: Build sequence string + */ + if (threadId == 0) { + + long totalLength = 0; + + for (i = 0; i < numUniqueSegment; i++) { + constructEntry_t* constructEntryPtr = &constructEntries[i]; + if (constructEntryPtr->isStart) { + totalLength += constructEntryPtr->length; + } + } + + sequencerPtr->sequence = (char*)P_MALLOC((totalLength+1) * sizeof(char)); + char* sequence = sequencerPtr->sequence; + assert(sequence); + + char* copyPtr = sequence; + long sequenceLength = 0; + + for (i = 0; i < numUniqueSegment; i++) { + constructEntry_t* constructEntryPtr = &constructEntries[i]; + /* If there are several start segments, we append in arbitrary order */ + if (constructEntryPtr->isStart) { + long newSequenceLength = sequenceLength + constructEntryPtr->length; + assert( newSequenceLength <= totalLength ); + copyPtr = sequence + sequenceLength; + sequenceLength = newSequenceLength; + do { + long numChar = segmentLength - constructEntryPtr->overlap; + if ((copyPtr + numChar) > (sequence + newSequenceLength)) { + TM_PRINT0("ERROR: sequence length != actual length\n"); + break; + } + memcpy(copyPtr, + constructEntryPtr->segment, + (numChar * sizeof(char))); + copyPtr += numChar; + } while ((constructEntryPtr = constructEntryPtr->nextPtr) != NULL); + assert(copyPtr <= (sequence + sequenceLength)); + } + } + + assert(sequence != NULL); + sequence[sequenceLength] = '\0'; + } + + TM_THREAD_EXIT(); +} + + +/* ============================================================================= + * sequencer_free + * ============================================================================= + */ +void +sequencer_free (sequencer_t* sequencerPtr) +{ + long i; + + table_free(sequencerPtr->hashToConstructEntryTable); + free(sequencerPtr->constructEntries); + for (i = 1; i < sequencerPtr->segmentLength; i++) { + table_free(sequencerPtr->startHashToConstructEntryTables[i]); + } + free(sequencerPtr->startHashToConstructEntryTables); + free(sequencerPtr->endInfoEntries); +#if 0 + /* TODO: fix mixed sequential/parallel allocation */ + hashtable_free(sequencerPtr->uniqueSegmentsPtr); + if (sequencerPtr->sequence != NULL) { + free(sequencerPtr->sequence); + } +#endif + free(sequencerPtr); +} + + +/* ============================================================================= + * TEST_SEQUENCER + * ============================================================================= + */ +#ifdef TEST_SEQUENCER + + +#include +#include +#include "segments.h" + + +char* gene1 = "gatcggcagc"; +char* segments1[] = { + "atcg", + "gcag", + "tcgg", + "cagc", + "gatc", + NULL +}; + +char* gene2 = "aaagc"; +char* segments2[] = { + "aaa", + "aag", + "agc", + NULL +}; + +char* gene3 = "aaacaaagaaat"; +char* segments3[] = { + "aaac", + "aaag", + "aaat", + NULL +}; + +char* gene4 = "ttggctacgtatcgcacggt"; +char* segments4[] = { + "cgtatcgc", + "tcgcacgg", + "gtatcgca", + "tatcgcac", + "atcgcacg", + "ttggctac", + "ctacgtat", + "acgtatcg", + "ctacgtat", + "cgtatcgc", + "atcgcacg", + "ggctacgt", + "tacgtatc", + "tcgcacgg", + "ttggctac", + "ggctacgt", + "atcgcacg", + "tatcgcac", + "cgtatcgc", + "acgtatcg", + "gtatcgca", + "gtatcgca", + "cgcacggt", + "tatcgcac", + "ttggctac", + "atcgcacg", + "acgtatcg", + "gtatcgca", + "ttggctac", + "tggctacg", + NULL +}; + +char* gene5 = "gatcggcagctggtacggcg"; +char* segments5[] = { + "atcggcag", + "gtacggcg", + "gatcggca", + "cagctggt", + "tggtacgg", + "gatcggca", + "gatcggca", + "tcggcagc", + "ggtacggc", + "tggtacgg", + "tcggcagc", + "gcagctgg", + "gatcggca", + "gctggtac", + "gatcggca", + "ctggtacg", + "ggcagctg", + "tcggcagc", + "gtacggcg", + "gcagctgg", + "ggcagctg", + "tcggcagc", + "cagctggt", + "tggtacgg", + "cagctggt", + "gcagctgg", + "gctggtac", + "cggcagct", + "agctggta", + "ctggtacg", + NULL +}; + +char* gene6 = "ttggtgagccgtaagactcc"; +char* segments6[] = { + "cgtaagac", + "taagactc", + "gtgagccg", + "gagccgta", + "gccgtaag", + "tgagccgt", + "gccgtaag", + "cgtaagac", + "ttggtgag", + "agccgtaa", + "gccgtaag", + "aagactcc", + "ggtgagcc", + "ttggtgag", + "agccgtaa", + "gagccgta", + "aagactcc", + "ttggtgag", + "gtaagact", + "ccgtaaga", + "ttggtgag", + "gagccgta", + "ggtgagcc", + "gagccgta", + "gccgtaag", + "aagactcc", + "gtaagact", + "ccgtaaga", + "tgagccgt", + "ttggtgag", + NULL +}; + +char* gene7 = "gatcggcagctggtacggcg"; +char* segments7[] = { + "atcggcag", + "gtacggcg", + "gatcggca", + "cagctggt", + "tggtacgg", + "gatcggca", + "gatcggca", + "tcggcagc", + "ggtacggc", + "tggtacgg", + "tcggcagc", + "gcagctgg", + "gatcggca", + "gctggtac", + "gatcggca", + "ctggtacg", + "ggcagctg", + "tcggcagc", + "gtacggcg", + "gcagctgg", + "ggcagctg", + "tcggcagc", + "cagctggt", + "tggtacgg", + "cagctggt", + "gcagctgg", + "gctggtac", + "cggcagct", + "agctggta", + "ctggtacg", + NULL +}; + +char* gene8 = "ttggtgagccgtaagactcc"; +char* segments8[] = { + "cgtaagac", + "taagactc", + "gtgagccg", + "gagccgta", + "gccgtaag", + "tgagccgt", + "gccgtaag", + "cgtaagac", + "ttggtgag", + "agccgtaa", + "gccgtaag", + "aagactcc", + "ggtgagcc", + "ttggtgag", + "agccgtaa", + "gagccgta", + "aagactcc", + "ttggtgag", + "gtaagact", + "ccgtaaga", + "ttggtgag", + "gagccgta", + "ggtgagcc", + "gagccgta", + "gccgtaag", + "aagactcc", + "gtaagact", + "ccgtaaga", + "tgagccgt", + "ttggtgag", + NULL +}; + + +static segments_t* +createSegments (char* segments[]) +{ + long i = 0; + segments_t* segmentsPtr = (segments_t*)malloc(sizeof(segments)); + + segmentsPtr->length = strlen(segments[0]); + segmentsPtr->contentsPtr = vector_alloc(1); + + while (segments[i] != NULL) { + bool_t status = vector_pushBack(segmentsPtr->contentsPtr, + (void*)segments[i]); + assert(status); + i++; + } + + segmentsPtr->minNum = vector_getSize(segmentsPtr->contentsPtr); + + return segmentsPtr; +} + + +static void +tester (char* gene, char* segments[]) +{ + segments_t* segmentsPtr; + sequencer_t* sequencerPtr; + + segmentsPtr = createSegments(segments); + sequencerPtr = sequencer_alloc(strlen(gene), segmentsPtr->length, segmentsPtr); + + sequencer_run((void*)sequencerPtr); + + printf("gene = %s\n", gene); + printf("sequence = %s\n", sequencerPtr->sequence); + assert(strcmp(sequencerPtr->sequence, gene) == 0); + + sequencer_free(sequencerPtr); +} + + +int +main () +{ + bool_t status = memory_init(1, 4, 2); + assert(status); + thread_startup(1); + + puts("Starting..."); + + /* Simple test */ + tester(gene1, segments1); + + /* Simple test with aliasing segments */ + tester(gene2, segments2); + + /* Simple test with non-overlapping segments */ + tester(gene3, segments3); + + /* Complex tests */ + tester(gene4, segments4); + tester(gene5, segments5); + tester(gene6, segments6); + tester(gene7, segments7); + tester(gene8, segments8); + + puts("Passed all tests."); + + return 0; +} + + +#endif /* TEST_SEQUENCER */ + + +/* ============================================================================= + * + * End of sequencer.c + * + * ============================================================================= + */ diff --git a/Robust/src/Benchmarks/SingleTM/genome/sequencer.h b/Robust/src/Benchmarks/SingleTM/genome/sequencer.h new file mode 100644 index 00000000..c624d86b --- /dev/null +++ b/Robust/src/Benchmarks/SingleTM/genome/sequencer.h @@ -0,0 +1,155 @@ +/* ============================================================================= + * + * sequencer.h + * + * ============================================================================= + * + * Copyright (C) Stanford University, 2006. All Rights Reserved. + * Author: Chi Cao Minh + * + * ============================================================================= + * + * For the license of bayes/sort.h and bayes/sort.c, please see the header + * of the files. + * + * ------------------------------------------------------------------------ + * + * For the license of kmeans, please see kmeans/LICENSE.kmeans + * + * ------------------------------------------------------------------------ + * + * For the license of ssca2, please see ssca2/COPYRIGHT + * + * ------------------------------------------------------------------------ + * + * For the license of lib/mt19937ar.c and lib/mt19937ar.h, please see the + * header of the files. + * + * ------------------------------------------------------------------------ + * + * For the license of lib/rbtree.h and lib/rbtree.c, please see + * lib/LEGALNOTICE.rbtree and lib/LICENSE.rbtree + * + * ------------------------------------------------------------------------ + * + * Unless otherwise noted, the following license applies to STAMP files: + * + * Copyright (c) 2007, Stanford University + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * * Neither the name of Stanford University nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY STANFORD UNIVERSITY ``AS IS'' AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL STANFORD UNIVERSITY BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF + * THE POSSIBILITY OF SUCH DAMAGE. + * + * ============================================================================= + */ + + +#ifndef SEQUENCER_H +#define SEQUENCER_H 1 + + +#include "hashtable.h" +#include "segments.h" +#include "table.h" +#include "tm.h" + + +typedef struct endInfoEntry endInfoEntry_t; +typedef struct constructEntry constructEntry_t; + + +typedef struct sequencer { + +/* public: */ + + char* sequence; + +/* private: */ + + segments_t* segmentsPtr; + + /* For removing duplicate segments */ + hashtable_t* uniqueSegmentsPtr; + + /* For matching segments */ + endInfoEntry_t* endInfoEntries; + table_t** startHashToConstructEntryTables; + + /* For constructing sequence */ + constructEntry_t* constructEntries; + table_t* hashToConstructEntryTable; + + /* For deallocation */ + long segmentLength; + +} sequencer_t; + + +typedef struct sequencer_run_arg { + sequencer_t* sequencerPtr; + segments_t* segmentsPtr; + long preAllocLength; + char* returnSequence; /* variable stores return value */ +} sequencer_run_arg_t; + + +/* ============================================================================= + * sequencer_alloc + * -- Returns NULL on failure + * ============================================================================= + */ +sequencer_t* +sequencer_alloc (long geneLength, long segmentLength, segments_t* segmentsPtr); + + +/* ============================================================================= + * sequencer_run + * ============================================================================= + */ + +void +sequencer_run (void* argPtr); + + +/* ============================================================================= + * sequencer_free + * ============================================================================= + */ +void +sequencer_free (sequencer_t* sequencerPtr); + + +#endif /* SEQUENCER_H */ + + +/* ============================================================================= + * + * End of sequencer.h + * + * ============================================================================= + */ diff --git a/Robust/src/Benchmarks/SingleTM/genome/sequencer.h~ b/Robust/src/Benchmarks/SingleTM/genome/sequencer.h~ new file mode 100644 index 00000000..c624d86b --- /dev/null +++ b/Robust/src/Benchmarks/SingleTM/genome/sequencer.h~ @@ -0,0 +1,155 @@ +/* ============================================================================= + * + * sequencer.h + * + * ============================================================================= + * + * Copyright (C) Stanford University, 2006. All Rights Reserved. + * Author: Chi Cao Minh + * + * ============================================================================= + * + * For the license of bayes/sort.h and bayes/sort.c, please see the header + * of the files. + * + * ------------------------------------------------------------------------ + * + * For the license of kmeans, please see kmeans/LICENSE.kmeans + * + * ------------------------------------------------------------------------ + * + * For the license of ssca2, please see ssca2/COPYRIGHT + * + * ------------------------------------------------------------------------ + * + * For the license of lib/mt19937ar.c and lib/mt19937ar.h, please see the + * header of the files. + * + * ------------------------------------------------------------------------ + * + * For the license of lib/rbtree.h and lib/rbtree.c, please see + * lib/LEGALNOTICE.rbtree and lib/LICENSE.rbtree + * + * ------------------------------------------------------------------------ + * + * Unless otherwise noted, the following license applies to STAMP files: + * + * Copyright (c) 2007, Stanford University + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * * Neither the name of Stanford University nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY STANFORD UNIVERSITY ``AS IS'' AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL STANFORD UNIVERSITY BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF + * THE POSSIBILITY OF SUCH DAMAGE. + * + * ============================================================================= + */ + + +#ifndef SEQUENCER_H +#define SEQUENCER_H 1 + + +#include "hashtable.h" +#include "segments.h" +#include "table.h" +#include "tm.h" + + +typedef struct endInfoEntry endInfoEntry_t; +typedef struct constructEntry constructEntry_t; + + +typedef struct sequencer { + +/* public: */ + + char* sequence; + +/* private: */ + + segments_t* segmentsPtr; + + /* For removing duplicate segments */ + hashtable_t* uniqueSegmentsPtr; + + /* For matching segments */ + endInfoEntry_t* endInfoEntries; + table_t** startHashToConstructEntryTables; + + /* For constructing sequence */ + constructEntry_t* constructEntries; + table_t* hashToConstructEntryTable; + + /* For deallocation */ + long segmentLength; + +} sequencer_t; + + +typedef struct sequencer_run_arg { + sequencer_t* sequencerPtr; + segments_t* segmentsPtr; + long preAllocLength; + char* returnSequence; /* variable stores return value */ +} sequencer_run_arg_t; + + +/* ============================================================================= + * sequencer_alloc + * -- Returns NULL on failure + * ============================================================================= + */ +sequencer_t* +sequencer_alloc (long geneLength, long segmentLength, segments_t* segmentsPtr); + + +/* ============================================================================= + * sequencer_run + * ============================================================================= + */ + +void +sequencer_run (void* argPtr); + + +/* ============================================================================= + * sequencer_free + * ============================================================================= + */ +void +sequencer_free (sequencer_t* sequencerPtr); + + +#endif /* SEQUENCER_H */ + + +/* ============================================================================= + * + * End of sequencer.h + * + * ============================================================================= + */ diff --git a/Robust/src/Benchmarks/SingleTM/genome/sequencer.o b/Robust/src/Benchmarks/SingleTM/genome/sequencer.o new file mode 100644 index 0000000000000000000000000000000000000000..b6aae4a1b0d9735a1fc3cfe4913622c51a43343c GIT binary patch literal 18504 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 literal 0 HcmV?d00001 diff --git a/Robust/src/Benchmarks/SingleTM/genome/staticTest b/Robust/src/Benchmarks/SingleTM/genome/staticTest new file mode 100755 index 0000000000000000000000000000000000000000..08b4cfe63fea469a3caa02203f0a802322b978dc GIT binary patch literal 6429 zcmb_gYiv}<6`s2fd#N9_jY}TTcHP*iQQ;bcp@uXG#u#Ga@UlrEh+Ot@y}Rvt*WJBK zZ7EV9TT~%q6$vWQil`w$1u2e76QsH-id-25A+;4kRsTdnL~SG!sOn11LoLeo`)2Og z*QQaS&9Tp(bLM+nANeY5GX1QB+zfm(>L!O_leKTh`%WC@U8M83q*KwBbbNU_l_?CF`K-B8UCJ=LsawA>uTJp{#I?H{qy* zzSOnXLehR1eCh{*5bLNFUlhW!5(C+cm3JaJ$Fc;P7Gsmv2&;P=Qsb$NRmj_MF_=qb zoPNNGaNz@yR7Py>>E6(3tu$55KD2-_8Tey=kV!SER25sdL7C#jj{~7H0M9^{L!P5V zw#d9V1F>Fs?xlQ)V$Oyg(A zv&lChrhWzBKaR~I#96!@I{5em>vbw`Eh$a}UK@u|x^|jkq~`Fo!mW3L^czx8o4a-flErK_`;i^y_hV`BiWS1@8z-KhOE6OD=2D5UNMGy`yDa}Yled;WKUd2!GQee-%(a4=i*$!a#O^!N`iqVT-XDqP4{cP{lHmHXt zU#=CRc)M~c`)R2(`kM!ld9=virI&wO@*OTYjjbPzbk!h)&`4J$BN^!m9SJm+PP|1_ z@f~CB$A#;~OO<<{xAskrENMiQD4*kcn(MasNy({eeYbRVq&P)i>&L)+8W`@*IP03?UtsVc)GNnQOQvx?a-g|Y4PoEHL=-Q$Yv3uY z{|`ScWd|X--flp0%^rhfnLXeNF!O&2Ok&+9F#uev4}$B#h)p~I-jDLB?}p@h(Dg%Pc_7+aKvV0#=}a?0e&9NXUTev3roA3ZD_$PvI;7GDV=gSBb3@ zMp;z)f-4~Wfgtu=;R^+S&csl8H$@=$Iz%8)4sZ%ua2EeUSr%U7D;R0+$SoNc$HR<*Cemn|A=iRB9|v7D1Kd+#ORY+=YJ zFyF!*z2TK+Ydby+#zECH`(!Y0;5Ym~29xuM9|08;BR&vzA_{Zea=yEz}zUfwEPQi_Bj?lfp^U`B}SE zKAFuq;X)>#N@VPKmG2CQKRn<>qL5Bb$)wg$zMUHsW+v;{X2*u^^FYV40|Pd?#*Ew1Lc)sVBAJBEQlvRp zh@ya5JC*6rYF{K8&DjUEh2u3sP`S`0T6K%l9efXRF)*Bi+?wT`1BUk-Am=B1T&U$P zPTmdR2*cK-z7RsJMgo^Q%j5asDd3vjGzj@6A+{C#5x()n@q97pmdCs#V#tqydBz}) z=Z<5*ZHLZt2vmvT`J)r;2NTD0$_+SqKG8%hiF-cJ7{u{>u?z~&GP+)-lXru8CZW!A zNjsD^st7u*PwnzJSb2q(}YedPiIwiV<9^ zC*j~(PLswRM*_) z9=P+s=`kQym;HO_te^4mel+nP>V->O1G79$#C@m@NbP&qqtiW(#&4(MlJ4^lVCy_| zg|O(GTnvTw{nMi}eK~MvwbSF{J=T*f{)mdQ%;1vt@r^?3bai5}EcGO4HSFS6xcSpq zycb-Zf;jRwTpZI#VQeDnrKWy#dwCyWA8XnV+*%gkl2$1>moWpk#h z{Z82!ED-lKWlJINWy)qNguJgQn>(c1kCcs00&(9_Hg_=f?xk$rBGr9D**H3a^tav5 zw-pfg1xmlW0=WK_%~8P|ow3yp!}YBE>I@6`|}uTJ~~QjafRyUxP)#`6~J?e6&d5YPPfUV&c| z+xsUNeAwYkXMFEL>hU#vi^RvUb$6XUYcGba=ZoR17mf70?G2;67TA2#;>xK* zJWs;r_Y$VGH^J5vhO%p(or2Bz&G`6s$ny-pqs&t$s>J~puiqYz!#?G~zY1H&Q-gSZ z0sDd*U#;%}aS=A3+n$rRc>KLt<7xTxV?m3IpL{ZK8dvv1o@tEaoS z5AUXywQ-KMrPJezXRSm!8;ztbd6Kpwg&~1c@?hF_?6|qQy=|2kq-YiL+-=1R0|Udl zg08I_XUo^drkx$nbXnSBWm=!DOCH{3U3lDeQn5Ze&%364F*94&u4)z5=ALaEI(n>a zn>O`!^;vx#8+y9f6gC*=_FQDxvNQ3y3G$&>SR40j?RciUQ}EocUV{OXPs6zWTk<|J zlRW2v+1hfz+G!_JdE9L}(~*20R{^Vk&`N$E0u}3G)Ppo%nAfkLePW(>(X*^M^~dvB zD;dee)3z>!!LT*%^YxsfEZkOfjBI9qAro_Wcd~4Gn?XOUX + +void function() { + static int myInt = 1; + printf("myInt:%d\n", myInt); + myInt *= 2; + printf("myInt:%d\n", myInt); +} + +int main(int argc,char *argv[]) +{ + function(); + function(); + function(); +} diff --git a/Robust/src/Benchmarks/SingleTM/genome/staticTest.c~ b/Robust/src/Benchmarks/SingleTM/genome/staticTest.c~ new file mode 100644 index 00000000..ca5630cb --- /dev/null +++ b/Robust/src/Benchmarks/SingleTM/genome/staticTest.c~ @@ -0,0 +1,15 @@ +#include + +void function() { + static int myInt = 0; + printf("myInt:%d\n", myInt); + myInt *= 2; + printf("myInt:%d\n", myInt); +} + +int main(int argc,char *argv[]) +{ + function(); + function(); + function(); +} diff --git a/Robust/src/Benchmarks/SingleTM/genome/table.c b/Robust/src/Benchmarks/SingleTM/genome/table.c new file mode 100644 index 00000000..d4e71d86 --- /dev/null +++ b/Robust/src/Benchmarks/SingleTM/genome/table.c @@ -0,0 +1,263 @@ +/* ============================================================================= + * + * table.c + * -- Fixed-size hash table + * + * ============================================================================= + * + * Copyright (C) Stanford University, 2006. All Rights Reserved. + * Author: Chi Cao Minh + * + * ============================================================================= + * + * For the license of bayes/sort.h and bayes/sort.c, please see the header + * of the files. + * + * ------------------------------------------------------------------------ + * + * For the license of kmeans, please see kmeans/LICENSE.kmeans + * + * ------------------------------------------------------------------------ + * + * For the license of ssca2, please see ssca2/COPYRIGHT + * + * ------------------------------------------------------------------------ + * + * For the license of lib/mt19937ar.c and lib/mt19937ar.h, please see the + * header of the files. + * + * ------------------------------------------------------------------------ + * + * For the license of lib/rbtree.h and lib/rbtree.c, please see + * lib/LEGALNOTICE.rbtree and lib/LICENSE.rbtree + * + * ------------------------------------------------------------------------ + * + * Unless otherwise noted, the following license applies to STAMP files: + * + * Copyright (c) 2007, Stanford University + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * * Neither the name of Stanford University nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY STANFORD UNIVERSITY ``AS IS'' AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL STANFORD UNIVERSITY BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF + * THE POSSIBILITY OF SUCH DAMAGE. + * + * ============================================================================= + */ + + +#include +#include +#include "list.h" +#include "table.h" +#include "types.h" + + +/* ============================================================================= + * table_alloc + * -- Returns NULL on failure + * ============================================================================= + */ +table_t* +table_alloc (long numBucket, long (*compare)(const void*, const void*)) +{ + table_t* tablePtr; + long i; + + tablePtr = (table_t*)malloc(sizeof(table_t)); + if (tablePtr == NULL) { + return NULL; + } + + tablePtr->buckets = (list_t**)malloc(numBucket * sizeof(list_t*)); + if (tablePtr->buckets == NULL) { + return NULL; + } + + for (i = 0; i < numBucket; i++) { + tablePtr->buckets[i] = list_alloc(compare); + if (tablePtr->buckets[i] == NULL) { + return NULL; + } + } + + tablePtr->numBucket = numBucket; + + return tablePtr; +} + + +/* ============================================================================= + * table_insert + * -- Returns TRUE if successful, else FALSE + * ============================================================================= + */ +bool_t +table_insert (table_t* tablePtr, ulong_t hash, void* dataPtr) +{ + long i = hash % tablePtr->numBucket; + + if (!list_insert(tablePtr->buckets[i], dataPtr)) { + return FALSE; + } + + return TRUE; +} + + +/* ============================================================================= + * TMtable_insert + * -- Returns TRUE if successful, else FALSE + * ============================================================================= + */ +bool_t +TMtable_insert (TM_ARGDECL table_t* tablePtr, ulong_t hash, void* dataPtr) +{ + long i = hash % tablePtr->numBucket; + + if (!TMLIST_INSERT(tablePtr->buckets[i], dataPtr)) { + return FALSE; + } + + return TRUE; +} + + +/* ============================================================================= + * table_remove + * -- Returns TRUE if successful, else FALSE + * ============================================================================= + */ +bool_t +table_remove (table_t* tablePtr, ulong_t hash, void* dataPtr) +{ + long i = hash % tablePtr->numBucket; + + if (!list_remove(tablePtr->buckets[i], dataPtr)) { + return FALSE; + } + + return TRUE; +} + + +/* ============================================================================= + * table_free + * ============================================================================= + */ +void +table_free (table_t* tablePtr) +{ +#if 0 + /* TODO: fix mixed sequential/parallel allocation */ + long i; + + for (i = 0; i < tablePtr->numBucket; i++) { + list_free(tablePtr->buckets[i]); + } +#endif + + free(tablePtr); +} + + +/* ============================================================================= + * TEST_TABLE + * ============================================================================= + */ +#ifdef TEST_TABLE + + +#include + + +static void +printTable (table_t* tablePtr) +{ + long i; + + for (i = 0; i < tablePtr->numBucket; i++) { + list_iter_t it; + printf("%2i: [", i); + list_iter_reset(&it, tablePtr->buckets[i]); + while (list_iter_hasNext(&it, tablePtr->buckets[i])) { + printf("%li ", *(long*)list_iter_next(&it, tablePtr->buckets[i])); + } + puts("]"); + } +} + + +int +main () +{ + table_t* tablePtr; + long hash[] = {3, 1, 4, 1, 5, 9, 2, 6, 8, 7, -1}; + long i; + + bool_t status = memory_init(1, 4, 2); + assert(status); + + puts("Starting..."); + + tablePtr = table_alloc(8, NULL); + + for (i = 0; hash[i] >= 0; i++ ) { + bool_t status = table_insert(tablePtr, + (ulong_t)hash[i], + (void*)&hash[i]) + assert(status); + printTable(tablePtr); + puts(""); + } + + for (i = 0; hash[i] >= 0; i++ ) { + bool_t status = table_remove(tablePtr, + (ulong_t)hash[i], + (void*)&hash[i]) + assert(status); + printTable(tablePtr); + puts(""); + } + + table_free(tablePtr); + + puts("Done."); + + return 0; +} + + +#endif /* TEST_TABLE */ + + +/* ============================================================================= + * + * End of table.c + * + * ============================================================================= + */ diff --git a/Robust/src/Benchmarks/SingleTM/genome/table.h b/Robust/src/Benchmarks/SingleTM/genome/table.h new file mode 100644 index 00000000..a2b4c839 --- /dev/null +++ b/Robust/src/Benchmarks/SingleTM/genome/table.h @@ -0,0 +1,142 @@ +/* ============================================================================= + * + * table.h + * -- Fixed-size hash table + * + * ============================================================================= + * + * Copyright (C) Stanford University, 2006. All Rights Reserved. + * Author: Chi Cao Minh + * + * ============================================================================= + * + * For the license of bayes/sort.h and bayes/sort.c, please see the header + * of the files. + * + * ------------------------------------------------------------------------ + * + * For the license of kmeans, please see kmeans/LICENSE.kmeans + * + * ------------------------------------------------------------------------ + * + * For the license of ssca2, please see ssca2/COPYRIGHT + * + * ------------------------------------------------------------------------ + * + * For the license of lib/mt19937ar.c and lib/mt19937ar.h, please see the + * header of the files. + * + * ------------------------------------------------------------------------ + * + * For the license of lib/rbtree.h and lib/rbtree.c, please see + * lib/LEGALNOTICE.rbtree and lib/LICENSE.rbtree + * + * ------------------------------------------------------------------------ + * + * Unless otherwise noted, the following license applies to STAMP files: + * + * Copyright (c) 2007, Stanford University + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * * Neither the name of Stanford University nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY STANFORD UNIVERSITY ``AS IS'' AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL STANFORD UNIVERSITY BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF + * THE POSSIBILITY OF SUCH DAMAGE. + * + * ============================================================================= + */ + + +#ifndef TABLE_H +#define TABLE_H 1 + + +#include "list.h" +#include "types.h" + + +typedef struct table { + list_t** buckets; + long numBucket; +} table_t; + + +/* ============================================================================= + * table_alloc + * -- Returns NULL on failure + * ============================================================================= + */ +table_t* +table_alloc (long numBucket, long (*compare)(const void*, const void*)); + + +/* ============================================================================= + * table_insert + * -- Returns TRUE if successful, else FALSE + * ============================================================================= + */ +bool_t +table_insert (table_t* tablePtr, ulong_t hash, void* dataPtr); + + +/* ============================================================================= + * TMtable_insert + * -- Returns TRUE if successful, else FALSE + * ============================================================================= + */ +bool_t +TMtable_insert (TM_ARGDECL table_t* tablePtr, ulong_t hash, void* dataPtr); + + +/* ============================================================================= + * table_remove + * -- Returns TRUE if successful, else FALSE + * ============================================================================= + */ +bool_t +table_remove (table_t* tablePtr, ulong_t hash, void* dataPtr); + + +/* ============================================================================= + * table_free + * ============================================================================= + */ +void +table_free (table_t* tablePtr); + + +#define TMTABLE_INSERT(t, h, d) TMtable_insert(TM_ARG t, h, d) + + +#endif /* TABLE_H */ + + +/* ============================================================================= + * + * End of table.h + * + * ============================================================================= + */ diff --git a/Robust/src/Benchmarks/SingleTM/genome/table.o b/Robust/src/Benchmarks/SingleTM/genome/table.o new file mode 100644 index 0000000000000000000000000000000000000000..269c4b6bdab297dfcf61e0e49d43c4d865d02429 GIT binary patch literal 6648 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