7 #include "misc/utils.h"
9 #ifdef MULTITHREAD_SUPPORT
10 #ifndef _GLIBCXX_PARALLEL
20 SASamples::SASamples(std::ifstream& sample_file, usint sample_rate) :
23 this->indexes = new DeltaVector(sample_file);
25 this->size = indexes->getSize();
26 this->items = indexes->getNumberOfItems();
27 this->integer_bits = length(this->items - 1);
29 this->samples = new ReadBuffer(sample_file, this->items, this->integer_bits);
30 this->buildInverseSamples();
33 SASamples::SASamples(uint* array, usint data_size, usint sample_rate) :
37 this->items = (this->size - 1) / this->rate + 1;
38 this->integer_bits = length(this->items - 1);
40 WriteBuffer sample_buffer(this->items, this->integer_bits);
41 DeltaEncoder encoder(INDEX_BLOCK_SIZE);
42 for(usint i = 0; i < this->size; i++)
44 if(array[i] % sample_rate == 0)
47 sample_buffer.writeItem(array[i] / sample_rate);
51 this->indexes = new DeltaVector(encoder, this->size);
52 this->samples = sample_buffer.getReadBuffer();
53 this->buildInverseSamples();
56 SASamples::SASamples(uint* inverse, DeltaVector* end_points, usint data_size, usint sample_rate) :
60 usint sequences = end_points->getNumberOfItems();
62 DeltaVector::Iterator iter(*(end_points));
64 // Determine the samples, insert them into a vector, and sort them.
65 usint start = 0, end = iter.select(0); // Closed range in padded collection.
66 usint seq_start = 0, seq_end = end; // Closed range in inverse SA.
67 std::vector<pair_type>* vec = new std::vector<pair_type>();
68 for(usint i = 0; i < sequences; i++)
70 for(usint j = seq_start; j <= seq_end; j += this->rate)
72 vec->push_back(pair_type(inverse[j] - sequences - 1, this->items));
75 start = nextMultipleOf(this->rate, end);
76 end = iter.selectNext();
77 seq_start = seq_end + 2;
78 seq_end = seq_start + end - start;
80 #ifdef MULTITHREAD_SUPPORT
81 #ifdef _GLIBCXX_PARALLEL
82 std::sort(vec->begin(), vec->end(), __gnu_parallel::sequential_tag());
84 std::sort(vec->begin(), vec->end(), mcstl::sequential_tag());
87 std::sort(vec->begin(), vec->end());
90 // Compress the samples.
91 this->integer_bits = length(this->items - 1);
93 WriteBuffer sample_buffer(this->items, this->integer_bits);
94 DeltaEncoder encoder(INDEX_BLOCK_SIZE);
95 for(usint i = 0; i < this->items; i++)
97 pair_type sample = (*vec)[i];
98 encoder.setBit(sample.first);
99 sample_buffer.writeItem(sample.second);
103 this->indexes = new DeltaVector(encoder, this->size);
104 this->samples = sample_buffer.getReadBuffer();
105 this->buildInverseSamples();
108 SASamples::SASamples(SASamples& index, SASamples& increment, usint* positions, usint number_of_positions, usint number_of_sequences) :
110 size(index.size + increment.size),
111 items(index.items + increment.items)
113 this->mergeSamples(index, increment, positions, number_of_positions, number_of_sequences);
117 index.inverse_samples = 0;
118 increment.indexes = 0;
119 increment.samples = 0;
120 increment.inverse_samples = 0;
122 this->buildInverseSamples();
125 SASamples::~SASamples()
127 delete this->indexes;
128 delete this->samples;
129 delete this->inverse_samples;
132 //--------------------------------------------------------------------------
135 SASamples::writeTo(std::ofstream& sample_file) const
137 this->indexes->writeTo(sample_file);
138 this->samples->writeBuffer(sample_file);
142 SASamples::reportSize() const
144 usint bytes = sizeof(*this);
145 bytes += this->indexes->reportSize();
146 bytes += this->samples->reportSize();
147 bytes += this->inverse_samples->reportSize();
151 //--------------------------------------------------------------------------
154 SASamples::buildInverseSamples()
156 WriteBuffer inverse_buffer(this->items, this->integer_bits);
157 this->samples->goToItem(0);
158 for(usint i = 0; i < this->items; i++)
160 inverse_buffer.goToItem(this->samples->readItem());
161 inverse_buffer.writeItem(i);
164 this->inverse_samples = inverse_buffer.getReadBuffer();
168 //--------------------------------------------------------------------------
171 SASamples::mergeSamples(SASamples& index, SASamples& increment, usint* positions, usint n, usint skip)
173 DeltaVector::Iterator first(*(index.indexes));
174 DeltaVector::Iterator second(*(increment.indexes));
175 ReadBuffer* first_samples = index.samples;
176 ReadBuffer* second_samples = increment.samples;
178 usint first_bit = first.select(0);
179 bool first_finished = false;
180 usint second_bit = second.select(0);
181 usint sum = index.items;
182 first_samples->goToItem(0);
183 second_samples->goToItem(0);
185 DeltaEncoder encoder(INDEX_BLOCK_SIZE);
186 this->integer_bits = length(this->items - 1);
187 WriteBuffer sample_buffer(this->items, this->integer_bits);
188 for(usint i = 0; i < n; i++, first_bit++)
190 while(!first_finished && first_bit < positions[i] - skip)
192 encoder.setBit(first_bit);
193 sample_buffer.writeItem(first_samples->readItem());
196 first_bit = first.selectNext() + i;
200 first_finished = true;
204 if(i == second_bit) // positions[i] is one
206 encoder.setBit(positions[i] - skip);
207 sample_buffer.writeItem(second_samples->readItem() + sum);
208 second_bit = second.selectNext();
212 while(!first_finished)
214 encoder.setBit(first_bit);
215 sample_buffer.writeItem(first_samples->readItem());
216 if(!first.hasNext()) { break; }
217 first_bit = first.selectNext() + n;
220 delete index.indexes;
221 delete index.samples;
222 delete index.inverse_samples;
223 delete increment.indexes;
224 delete increment.samples;
225 delete increment.inverse_samples;
227 this->indexes = new DeltaVector(encoder, size);
228 this->samples = sample_buffer.getReadBuffer();