void SkPictureData::WriteFactories(SkWStream* stream, const SkFactorySet& rec) {
int count = rec.count();
SkAutoSTMalloc<16, SkFlattenable::Factory> storage(count);
SkFlattenable::Factory* array = (SkFlattenable::Factory*)storage.get();
rec.copyToArray(array);
size_t size = compute_chunk_size(array, count);
// TODO: write_tag_size should really take a size_t
write_tag_size(stream, SK_PICT_FACTORY_TAG, (uint32_t) size);
SkDEBUGCODE(size_t start = stream->bytesWritten());
stream->write32(count);
for (int i = 0; i < count; i++) {
const char* name = SkFlattenable::FactoryToName(array[i]);
if (nullptr == name || 0 == *name) {
stream->writePackedUInt(0);
} else {
size_t len = strlen(name);
stream->writePackedUInt(len);
stream->write(name, len);
}
}
SkASSERT(size == (stream->bytesWritten() - start));
}
//----------------------------------------------------------------------
// TODO(stevescott): This code currently discards the tim_sampler
void BLCSSS::tim_draw(){
int nvars = m_->coef().nvars();
if(nvars == 0) return;
int chunk_size = compute_chunk_size(max_tim_chunk_size_);
int number_of_chunks = compute_number_of_chunks(max_tim_chunk_size_);
assert(number_of_chunks * chunk_size >= nvars);
for(int chunk = 0; chunk < number_of_chunks; ++chunk) {
clock_t mode_start = clock();
TIM tim_sampler(log_posterior(chunk, max_tim_chunk_size_), tdf_, &rng());
Vector beta = m_->included_coefficients();
int start = chunk_size * chunk;
int elements_remaining = nvars - start;
VectorView beta_chunk(beta,
start,
std::min(elements_remaining, chunk_size));
bool ok = tim_sampler.locate_mode(beta_chunk);
move_accounting_.stop_time("tim mode finding", mode_start);
if (ok) {
move_accounting_.record_acceptance("tim mode finding");
tim_sampler.fix_mode(true);
MoveTimer timer = move_accounting_.start_time("TIM chunk");
beta_chunk = tim_sampler.draw(beta_chunk);
m_->set_included_coefficients(beta);
if (tim_sampler.last_draw_was_accepted()) {
move_accounting_.record_acceptance("TIM chunk");
} else {
move_accounting_.record_rejection("TIM chunk");
}
} else {
move_accounting_.record_rejection("tim mode finding");
rwm_draw_chunk(chunk);
}
}
}
//----------------------------------------------------------------------
void BLCSSS::rwm_draw_chunk(int chunk){
clock_t start = clock();
const Selector &inc(m_->coef().inc());
int nvars = inc.nvars();
Vec full_nonzero_beta = m_->beta(); // only nonzero components
// Compute information matrix for proposal distribution. For
// efficiency, also compute the log-posterior of the current beta.
Vec mu(inc.select(pri_->mu()));
Spd siginv(inc.select(pri_->siginv()));
double original_logpost = dmvn(full_nonzero_beta, mu, siginv, 0, true);
const std::vector<Ptr<BinomialRegressionData> > &data(m_->dat());
int nobs = data.size();
int full_chunk_size = compute_chunk_size();
int chunk_start = chunk * full_chunk_size;
int elements_remaining = nvars - chunk_start;
int this_chunk_size = std::min(elements_remaining, full_chunk_size);
Selector chunk_selector(nvars, false);
for(int i = chunk_start; i< chunk_start + this_chunk_size; ++i) {
chunk_selector.add(i);
}
Spd proposal_ivar = chunk_selector.select(siginv);
for(int i = 0; i < nobs; ++i){
Vec x = inc.select(data[i]->x());
double eta = x.dot(full_nonzero_beta);
double prob = plogis(eta);
double weight = prob * (1-prob);
VectorView x_chunk(x, chunk_start, this_chunk_size);
// Only upper triangle is accessed. Need to reflect at end of loop.
proposal_ivar.add_outer(x_chunk, weight, false);
int yi = data[i]->y();
int ni = data[i]->n();
original_logpost += dbinom(yi, ni, prob, true);
}
proposal_ivar.reflect();
VectorView beta_chunk(full_nonzero_beta, chunk_start, this_chunk_size);
if(tdf_ > 0){
beta_chunk = rmvt_ivar_mt(
rng(), beta_chunk, proposal_ivar / rwm_variance_scale_factor_, tdf_);
}else{
beta_chunk = rmvn_ivar_mt(
rng(), beta_chunk, proposal_ivar / rwm_variance_scale_factor_);
}
double logpost = dmvn(full_nonzero_beta, mu, siginv, 0, true);
Vec full_beta(inc.expand(full_nonzero_beta));
logpost += m_->log_likelihood(full_beta, 0, 0, false);
double log_alpha = logpost - original_logpost;
double logu = log(runif_mt(rng()));
++rwm_chunk_attempts_;
if(logu < log_alpha){
m_->set_beta(full_nonzero_beta);
++rwm_chunk_successes_;
}
clock_t end = clock();
rwm_chunk_times_ += double(end - start) / CLOCKS_PER_SEC;
}
//----------------------------------------------------------------------
void BLCSSS::rwm_draw_chunk(int chunk){
const Selector &inc(m_->coef().inc());
int nvars = inc.nvars();
Vector full_nonzero_beta = m_->included_coefficients();
// Compute information matrix for proposal distribution. For
// efficiency, also compute the log-posterior of the current beta.
Vector mu(inc.select(pri_->mu()));
SpdMatrix siginv(inc.select(pri_->siginv()));
double original_logpost = dmvn(full_nonzero_beta, mu, siginv, 0, true);
const std::vector<Ptr<BinomialRegressionData> > &data(m_->dat());
int nobs = data.size();
int full_chunk_size = compute_chunk_size(max_rwm_chunk_size_);
int chunk_start = chunk * full_chunk_size;
int elements_remaining = nvars - chunk_start;
int this_chunk_size = std::min(elements_remaining, full_chunk_size);
Selector chunk_selector(nvars, false);
for(int i = chunk_start; i< chunk_start + this_chunk_size; ++i) {
chunk_selector.add(i);
}
SpdMatrix proposal_ivar = chunk_selector.select(siginv);
for(int i = 0; i < nobs; ++i){
Vector x = inc.select(data[i]->x());
double eta = x.dot(full_nonzero_beta);
double prob = plogis(eta);
double weight = prob * (1-prob);
VectorView x_chunk(x, chunk_start, this_chunk_size);
// Only upper triangle is accessed. Need to reflect at end of loop.
proposal_ivar.add_outer(x_chunk, weight, false);
original_logpost += dbinom(data[i]->y(), data[i]->n(), prob, true);
}
proposal_ivar.reflect();
VectorView beta_chunk(full_nonzero_beta, chunk_start, this_chunk_size);
if(tdf_ > 0){
beta_chunk = rmvt_ivar_mt(
rng(), beta_chunk, proposal_ivar / rwm_variance_scale_factor_, tdf_);
}else{
beta_chunk = rmvn_ivar_mt(
rng(), beta_chunk, proposal_ivar / rwm_variance_scale_factor_);
}
double logpost = dmvn(full_nonzero_beta, mu, siginv, 0, true);
Vector full_beta(inc.expand(full_nonzero_beta));
logpost += m_->log_likelihood(full_beta, 0, 0, false);
double log_alpha = logpost - original_logpost;
double logu = log(runif_mt(rng()));
if (logu < log_alpha) {
m_->set_included_coefficients(full_nonzero_beta);
move_accounting_.record_acceptance("rwm_chunk");
} else {
move_accounting_.record_rejection("rwm_chunk");
}
}
static int compute_chunks_per_sect(struct params *fd,
int tracksize,
int sizecode,
int *gap,
int mask,
int tailsize)
{
int tot_size;
if (! (mask & SET_FMTGAP))
*gap = compute_gap(fd, tracksize);
while(1) {
compute_chunk_size(fd, *gap, tailsize);
tot_size=compute_tot_size(fd, fd->chunksize, *gap, tailsize);
if(fd->raw_capacity >= tot_size)
/* enough space available, ok */
break;
if ((mask & SET_FMTGAP) || *gap <= 0)
/* does not fit on disk */
return -1;
*gap -= (tot_size-fd->raw_capacity) * GAP_DIVISOR / tracksize;
if (*gap < 0)
*gap = 0;
}
convert_chunksize(fd);
if (mask & SET_INTERLEAVE)
fd->actual_interleave = fd->preset_interleave;
if(verbosity >= 9) {
printf("%d raw bytes per cylinder\n", tot_size );
printf("%d final gap\n",
fd->raw_capacity - tot_size );
}
return 0;
}
//----------------------------------------------------------------------
void BLCSSS::tim_draw(){
int nvars = m_->coef().nvars();
if(nvars == 0) return;
int chunk_size = compute_chunk_size();
int number_of_chunks = compute_number_of_chunks();
assert(number_of_chunks * chunk_size >= nvars);
for(int chunk = 0; chunk < number_of_chunks; ++chunk) {
++tim_chunk_attempts_;
clock_t mode_start = clock();
TIM tim_sampler(log_posterior(chunk), tdf_);
Vec beta = m_->beta();
int start = chunk_size * chunk;
int elements_remaining = nvars - start;
VectorView beta_chunk(beta,
start,
std::min(elements_remaining, chunk_size));
bool ok = tim_sampler.locate_mode(beta_chunk);
clock_t mode_end = clock();
double mode_time = double(mode_end - mode_start) / CLOCKS_PER_SEC;
tim_mode_finding_times_ += mode_time;
if(ok){
tim_sampler.fix_mode(true);
clock_t trial_start = clock();
beta_chunk = tim_sampler.draw(beta_chunk);
m_->set_beta(beta);
tim_chunk_successes_ += tim_sampler.last_draw_was_accepted();
clock_t trial_end = clock();
tim_trial_times_ += double(trial_end - trial_start) / CLOCKS_PER_SEC;
}else{
rwm_draw_chunk(chunk);
tim_mode_finding_wasted_time_ += mode_time;
++tim_chunk_mode_failures_;
}
}
}
//----------------------------------------------------------------------
BinomialLogitLogPostChunk BLCSSS::log_posterior(
int chunk, int max_chunk_size)const{
return BinomialLogitLogPostChunk(
m_, pri_.get(), compute_chunk_size(max_chunk_size), chunk);
}
// {{{ parse_args
int parse_args(int argc, char** argv, cnf_t* config)
{
int i;
char optC;
double size_as_double;
char *size_suffix;
static struct option long_options[] =
{
{"help", no_argument, 0, 'h'},
{"verbose", no_argument, 0, 'v'},
{"version", no_argument, 0, 'V'},
{"aes-ctr", no_argument, 0, 'a'},
{"amount", required_argument, 0, 'n'},
{"method", required_argument, 0, 'm'},
{"output", required_argument, 0, 'o'},
{"threads", required_argument, 0, 't'},
{"aes-keys", required_argument, 0, 'k'},
{0, 0, 0, 0}
};
opterr = 0;
while (1)
{
/* getopt_long stores the option index here. */
int option_index = 0;
optC = getopt_long (argc, argv, "hak:vVn:m:o:t:",
long_options, &option_index);
/* Detect the end of the options. */
if (optC == -1)
break;
switch (optC)
{
case 'V':
config->version_flag = 1;
break;
case 'v':
config->verbose_flag = 1;
break;
case 'h':
config->help_flag = 1;
break;
case 'a':
config->aes_flag = 1;
break;
case 'k':
config->aeskeys_filename = optarg;
break;
case 'n':
// {{{ parse amount
size_as_double = strtod(optarg,&size_suffix);
if ((optarg == size_suffix) ||
errno == ERANGE ||
(size_as_double < 0) ||
(size_as_double >= UINT64_MAX) ){
#ifdef _X86_64
EPRINT("Size has to be in range <0, %lu>!\n",UINT64_MAX);
#else
EPRINT("Size has to be in range <0, %llu>!\n",UINT64_MAX);
#endif // _X86_64
//exit(EXIT_FAILURE);
return EXIT_FAILURE;
}
if(strlen(size_suffix) > 0)
{
switch(*size_suffix)
{
case 't': case 'T':
size_as_double *= pow(2,40);
break;
case 'g': case 'G':
size_as_double *= pow(2,30);
break;
case 'm': case 'M':
size_as_double *= pow(2,20);
break;
case 'k': case 'K':
size_as_double *= pow(2,10);
break;
default:
EPRINT("Unknown suffix %s when parsing %s.\n",
size_suffix,
optarg);
return EXIT_FAILURE;
}
}
// }}} parse amount
config->bytes = (size_t)floor(size_as_double);
break;
case 't':
// {{{ parse threads
{
char*p;
config->threads=strtoul(optarg,&p,10);
if((p ==optarg)||(*p !=0)
||errno ==ERANGE
||(config->threads <1)
||(config->threads >=INT_MAX)
||(config->threads>16384))
{
EPRINT("Invalid threads parameter!\n");
return EXIT_FAILURE;
}
}
//config->threads = strtoumax(optarg, NULL, 10);
// }}} parse threads
break;
case 'o':
config->output_filename = optarg;
break;
case 'm': // method
// {{{ parse method
config->method = METHODS_COUNT;
for(i = 0; i<METHODS_COUNT; i++)
{
if(strcmp(optarg,METHOD_NAMES[i]) == 0)
{
config->method = i;
break;
}
}
// test default value
if(config->method == METHODS_COUNT)
{
EPRINT("Error: Unknown method to use!\n");
print_available_methods(stderr);
//exit(EXIT_FAILURE);
return EXIT_FAILURE;
}
break;
// }}} parse method
case '?':
EPRINT("An unknown parameter.\n");
//exit(EXIT_FAILURE);
return EXIT_FAILURE;
default:
EPRINT("An unknown parameter %c.\n",optC);
//exit(EXIT_FAILURE);
return EXIT_FAILURE;
//abort ();
}
}
if(config->aes_flag == 0 && config->aeskeys_filename != NULL){
EPRINT("You have specified keyfile for AES, but did not enable it.\n"
"The -k argument has to be specified in pair with -a.\n");
return EXIT_FAILURE;
}
compute_chunk_size(config);
return EXIT_SUCCESS;
}