/**
* \return Gaussian second centered moment
*
* Computes the covariance from other representation of not available
*
* \throws GaussianUninitializedException if the Gaussian is of dynamic-size
* and has not been initialized using SetStandard(dimension).
* \throws InvalidGaussianRepresentationException if non-of theember function)
* representation can be used as a source
*/
virtual const SecondMoment& covariance() const
{
if (dimension() == 0)
{
fl_throw(GaussianUninitializedException());
}
if (is_dirty(CovarianceMatrix) && is_dirty(DiagonalCovarianceMatrix))
{
switch (select_first_representation<4>({{DiagonalSquareRootMatrix,
DiagonalPrecisionMatrix,
SquareRootMatrix,
PrecisionMatrix}}))
{
case SquareRootMatrix:
covariance_ = square_root_ * square_root_.transpose();
break;
case PrecisionMatrix:
covariance_ = precision_.inverse();
break;
case DiagonalSquareRootMatrix:
covariance_.setZero(dimension(), dimension());
for (int i = 0; i < square_root_.diagonalSize(); ++i)
{
covariance_(i, i) = square_root_(i, i) * square_root_(i, i);
}
break;
case DiagonalPrecisionMatrix:
covariance_.setZero(dimension(), dimension());
for (int i = 0; i < precision_.diagonalSize(); ++i)
{
covariance_(i, i) = 1./precision_(i, i);
}
break;
default:
fl_throw(InvalidGaussianRepresentationException());
break;
}
updated_internally(CovarianceMatrix);
}
return covariance_;
}
Attribute select_first_representation(
const std::array<Attribute, AttributeCount>& representations
) const noexcept
{
for (auto& rep: representations) if (!is_dirty(rep)) return rep;
return Attributes;
}
bool RedScreen::_invalidate(const SpiceRect& rect, bool urgent, uint64_t& update_mark)
{
RecurciveLock lock(_update_lock);
bool update_triger = !is_dirty() && (urgent || !_periodic_update);
region_add(&_dirty_region, &rect);
update_mark = _update_mark;
return update_triger;
}
/**
* \return Covariance determinant
*
* \throws see covariance
*/
virtual Real covariance_determinant() const
{
if (is_dirty(Determinant))
{
determinant_ = covariance().determinant();
updated_internally(Determinant);
}
return determinant_;
}
void slot_flush(int n)
{
if (n < 0 || n >= NUM_SLOTS)
return;
slot_t *slot = slots[n];
if (slot != NULL && is_dirty(slot))
{
// TODO: Save to disk & reset dirty-flag
slot->flags &= ~SLOT_DIRTY;
}
}
/**
* \return True if the covariance matrix has a full rank
*
* \throws see covariance()
*/
virtual bool has_full_rank() const
{
if (is_dirty(Rank))
{
full_rank_ =
covariance().colPivHouseholderQr().rank() == covariance().rows();
updated_internally(Rank);
}
return full_rank_;
}
/**
* \return Gaussian second centered moment in the square root form (
* Cholesky decomposition)
*
* Computes the square root from other representation of not available
*
* \throws GaussianUninitializedException if the Gaussian is of dynamic-size
* and has not been initialized using SetStandard(dimension).
* \throws InvalidGaussianRepresentationException if non-of the
* representation can be used as a source
*/
virtual const SecondMoment& square_root() const
{
if (dimension() == 0)
{
fl_throw(GaussianUninitializedException());
}
if (is_dirty(SquareRootMatrix) && is_dirty(DiagonalSquareRootMatrix))
{
const SecondMoment& cov = covariance();
switch (select_first_representation<4>({{DiagonalCovarianceMatrix,
DiagonalPrecisionMatrix,
CovarianceMatrix,
PrecisionMatrix}}))
{
case CovarianceMatrix:
case PrecisionMatrix:
fl::square_root(cov, square_root_);
break;
case DiagonalCovarianceMatrix:
case DiagonalPrecisionMatrix:
square_root_.setZero(dimension(), dimension());
for (int i = 0; i < square_root_.rows(); ++i)
{
square_root_(i, i) = std::sqrt(cov(i, i));
}
break;
default:
fl_throw(InvalidGaussianRepresentationException());
break;
}
updated_internally(SquareRootMatrix);
}
return square_root_;
}
/**
* \return Gaussian second centered moment in the precision form (inverse
* of the covariance)
*
* Computes the precision from other representation of not available
*
* \throws GaussianUninitializedException if the Gaussian is of dynamic-size
* and has not been initialized using SetStandard(dimension).
* \throws InvalidGaussianRepresentationException if non-of the
* representation can be used as a source
*/
virtual const SecondMoment& precision() const
{
if (dimension() == 0)
{
fl_throw(GaussianUninitializedException());
}
if (is_dirty(PrecisionMatrix) && is_dirty(DiagonalPrecisionMatrix))
{
const SecondMoment& cov = covariance();
switch (select_first_representation<4>({{DiagonalCovarianceMatrix,
DiagonalSquareRootMatrix,
CovarianceMatrix,
SquareRootMatrix}}))
{
case CovarianceMatrix:
case SquareRootMatrix:
precision_ = covariance().inverse();
break;
case DiagonalCovarianceMatrix:
case DiagonalSquareRootMatrix:
precision_.setZero(dimension(), dimension());
for (int i = 0; i < cov.rows(); ++i)
{
precision_(i, i) = 1./cov(i, i);
}
break;
default:
fl_throw(InvalidGaussianRepresentationException());
break;
}
updated_internally(PrecisionMatrix);
}
return precision_;
}
/**
* This function will select a page (based on second chance)
* and swap it out to file system. However if the selected page
* was not dirty then we just need to mark it swapped again and
* can return immediatly.
* We stop the initiator thread as long as we're swapping
* data out to the file system. The thread is restarted in the
* write callback function (above).
*
* @param initiator ID of the thread who caused the swapping to happen
* @return SWAPPING_PENDING in case we need to write the page to the disk
* SWAPPING_COMPLETE in case the page was not dirty
* OUT_OF_SWAP_SPACE if our swap space is already full
* NO_PAGE_AVAILABLE if second_chance_select did not find a page
*/
int swap_out(L4_ThreadId_t initiator) {
page_queue_item* page = second_chance_select(&active_pages_head);
if(page == NULL) {
return NO_PAGE_AVAILABLE;
}
assert(!is_referenced(page));
// decide where in the swap file our page will be
if(page->swap_offset < 0 && (page->swap_offset = allocate_swap_entry()) < 0)
return OUT_OF_SWAP_SPACE;
dprintf(1, "swap_out: Second chance selected page: thread:0x%X vaddr:0x%X swap_offset:0x%X\n", page->tid, page->virtual_address, page->swap_offset);
if(is_dirty(page)) {
dprintf(1, "Selected page is dirty, need to write to swap space\n");
page->to_swap = PAGESIZE;
page->initiator = initiator;
TAILQ_INSERT_TAIL(&swapping_pages_head, page, entries);
file_table_entry* swap_fd = get_process(root_thread_g)->filetable[SWAP_FD];
assert(swap_fd != NULL);
data_ptr physical_page = pager_physical_lookup(page->tid, page->virtual_address);
assert(physical_page != NULL);
// write page in swap file
assert(PAGESIZE % BATCH_SIZE == 0);
for(int write_offset=0; write_offset < page->to_swap; write_offset += BATCH_SIZE) {
nfs_write(
&swap_fd->file->nfs_handle,
page->swap_offset + write_offset,
BATCH_SIZE,
physical_page + write_offset,
&swap_write_callback,
(int)page
);
}
return SWAPPING_PENDING;
}
else {
assert(page->swap_offset >= 0);
page_table_entry* pte = pager_table_lookup(page->tid, page->virtual_address);
frame_free(CLEAR_LOWER_BITS(pte->address));
mark_swapped(pte, page->swap_offset);
free(page);
return SWAPPING_COMPLETE;
}
}
/**
* \return Log normalizing constant
*
* \throws see has_full_rank()
*/
virtual Real log_normalizer() const
{
if (is_dirty(Normalizer))
{
if (has_full_rank())
{
log_norm_ =
-0.5
* (std::log(covariance_determinant())
+ Real(dimension()) * std::log(2.0 * M_PI));
}
else
{
log_norm_ = 0.0; // FIXME
}
updated_internally(Normalizer);
}
return log_norm_;
}
void RedScreen::periodic_update()
{
bool need_update;
RecurciveLock lock(_update_lock);
if (is_dirty()) {
need_update = true;
} else {
if (!_forec_update_timer) {
_owner.deactivate_interval_timer(*_update_timer);
_periodic_update = false;
}
need_update = false;
}
lock.unlock();
if (need_update) {
if (update_by_interrupt()) {
interrupt_update();
} else {
update();
}
}
}
block_t cl_list_consolidate(const void * cfg,
serial_t serialno,
block_t list_block,
uint8_t type,
int item_size,
int (*is_dirty)(void*),
int (*is_free)(void*)){
cl_block_data_t cl_block_data;
cl_block_data_t new_cl_block_data;
cl_list_block_t * list;
cl_list_block_t * new_list;
block_t new_block;
block_t prev_block;
block_t old_prev_block;
block_t old_current_block;
int i, j;
block_t new_current_block;
int total_items;
int copied_items;
new_block = cl_block_alloc(cfg, serialno, list_block, type);
if ( new_block == BLOCK_INVALID ){
cl_error("no more blocks\n");
return BLOCK_INVALID;
}
list = (cl_list_block_t*)(cl_block_data.data);
new_list = (cl_list_block_t*)(new_cl_block_data.data);
total_items = calc_total_items(item_size);
cl_debug(DEBUG_LEVEL, "consolidate list on new block %d\n", new_block);
new_cl_block_data.hdr.serialno = serialno;
new_cl_block_data.hdr.type = type;
new_cl_block_data.hdr.status = 0xFF;
memset(new_cl_block_data.data, 0xFF, BLOCK_DATA_SIZE);
new_current_block = new_block;
new_list->hdr.prev = BLOCK_INVALID;
old_prev_block = BLOCK_INVALID;
j = 0;
copied_items = 0;
for( list->hdr.next = list_block; list->hdr.next != BLOCK_INVALID ; ){
old_current_block = list->hdr.next;
if ( cl_block_load(cfg, list->hdr.next, &cl_block_data) < 0 ){
return -1;
}
//make sure the loaded block is valid
if ( (list->hdr.prev != old_prev_block) || //linking is not correct
(list_typeisvalid(cl_block_data.hdr.type) == false) || //block type is not correct
(serialno != cl_block_data.hdr.serialno) || //serialno is not correct
(cl_block_data.hdr.status != BLOCK_STATUS_CLOSED) //block status must be closed
){
cl_debug(DEBUG_LEVEL, "--------------------END OF LIST %d != %d %d != %d 0x%X != 0x%X\n",
list->hdr.prev, old_prev_block,
serialno, cl_block_data.hdr.serialno,
cl_block_data.hdr.status, BLOCK_STATUS_CLOSED);
break; //end of the list
}
old_prev_block = old_current_block;
for(i = 0; i < total_items; i++){
if ( is_free( get_item(list, i, item_size) )){
break;
} else if ( !is_dirty( get_item(list, i, item_size) ) ){
memcpy(get_item(new_list, j, item_size), get_item(list, i, item_size), item_size);
j++;
copied_items++;
if ( j == total_items ){
//save the current block to the disk
new_list->hdr.next = cl_block_alloc(cfg, serialno, new_current_block, type | BLOCK_TYPE_LINKED_LIST_FLAG);
cl_debug(DEBUG_LEVEL, "save block %d (prev:%d, next:%d)\n", new_current_block, new_list->hdr.prev, new_list->hdr.next);
//hwpl_debug("save block %d (prev:%d, next:%d)\n", new_current_block, new_list->hdr.prev, new_list->hdr.next);
if ( cl_block_save(cfg, new_current_block, &new_cl_block_data) < 0 ){
cl_error("failed to save block %d\n", new_current_block);
return -1;
}
prev_block = new_current_block;
new_current_block = new_list->hdr.next;
memset(new_cl_block_data.data, 0xFF, BLOCK_DATA_SIZE);
new_list->hdr.prev = prev_block;
j = 0;
}
}
}
}
//save the last block
new_list->hdr.next = BLOCK_INVALID;
if ( cl_block_save(cfg, new_current_block, &new_cl_block_data) < 0 ){
return -1;
}
return new_block;
}
int
main(int argc, char *argv[])
#endif
{
spcs_s_info_t ustats;
struct timeval tout;
fd_set readfds;
char *errmessage, *ch;
int c, period, prev;
int count = 0, dflag = 0;
int fd = fileno(stdin);
errmessage = NULL;
if (strcmp(argv[0], "sd_stats") != 0)
errmessage = getenv("SD_STATS_USAGE");
if (errmessage == NULL)
errmessage = gettext("Usage: sd_stats [-Mz] "
"[-d delay_time] [-l logfile] [-r range]");
if (SDBC_IOCTL(SDBC_MAXFILES, &sdbc_max_devices,
0, 0, 0, 0, &ustats) == SPCS_S_ERROR) {
if (ustats) { /* if SPCS_S_ERROR */
spcs_s_report(ustats, stderr);
spcs_s_ufree(&ustats);
}
(void) fprintf(stderr, gettext("cannot get maxfiles\n"));
exit(1);
}
on_off = calloc(sdbc_max_devices, sizeof (int));
dual_on_off = calloc(sdbc_max_devices, sizeof (int));
updates_prev = calloc(sdbc_max_devices, sizeof (int));
samples = calloc(sdbc_max_devices, sizeof (int));
rate_prev = calloc(sdbc_max_devices, sizeof (double));
cs_cur = malloc(sizeof (_sd_stats_t) +
(sdbc_max_devices - 1) * sizeof (_sd_shared_t));
cs_prev = malloc(sizeof (_sd_stats_t) +
(sdbc_max_devices - 1) * sizeof (_sd_shared_t));
cs_persec = malloc(sizeof (_sd_stats_t) +
(sdbc_max_devices - 1) * sizeof (_sd_shared_t));
range = malloc(100);
if (!on_off || !dual_on_off || !updates_prev || !samples ||
!rate_prev || !cs_cur || !cs_prev || !cs_persec || !range) {
(void) fprintf(stderr, gettext("no free memory\n"));
exit(1);
}
*range = '\0';
while ((c = getopt(argc, argv, "DMzd:l:r:h")) != EOF) {
prev = c;
switch (c) {
case 'd':
delay = atoi(optarg);
ch = optarg;
while (*ch != '\0') {
if (!isdigit(*ch))
errflg++;
ch++;
}
break;
case 'l':
logfd = open(optarg, O_CREAT|O_WRONLY|O_TRUNC, 0644);
break;
case 'r':
ch = optarg;
while (*ch != '\0') {
if ((!isdigit(*ch)) && (*ch != ',') &&
(*ch != ':'))
errflg++;
ch++;
}
if (errflg)
break;
range = realloc((char *)range,
(strlen(range) + strlen(optarg) + 1)
* sizeof (char));
if (had_r_option)
(void) strcat(range, ",");
(void) strcat(range, optarg);
had_r_option = 1;
break;
case 'z':
if (SDBC_IOCTL(SDBC_ZAP_STATS, 0, 0, 0, 0, 0,
&ustats) == SPCS_S_ERROR) {
if (ustats) {
spcs_s_report(ustats, stderr);
spcs_s_ufree(&ustats);
}
}
break;
case 'D':
dflag = 1;
break;
case 'M':
mirror_sw = 1;
break;
case 'h':
case '?':
default :
errflg++;
break;
}
}
if (errflg) {
(void) fprintf(stderr, "%s\n", errmessage);
exit(1);
} else if (!prev) {
if (argc > 1) {
(void) fprintf(stderr, "%s\n", errmessage);
exit(1);
}
}
if (dflag) {
exit(is_dirty());
}
/*
* A few curses routines to setup screen and tty interface
*/
(void) initscr();
(void) cbreak();
(void) noecho();
(void) nonl();
(void) erase();
(void) clear();
(void) refresh();
setup_ranges(range);
/*
* Set signal handle
*/
(void) sigset(SIGPIPE, leave);
(void) sigset(SIGINT, leave);
(void) sigset(SIGQUIT, leave);
(void) signal(SIGFPE, leave);
(void) signal(SIGSEGV, leave);
USEC_INIT();
currtime = USEC_READ();
/*
* Wait one second before reading the new values
*/
(void) sleep(1);
/*CONSTCOND*/
while (1) {
lasttime = currtime;
currtime = USEC_READ();
/*
* If less that 1 second, force it to one second
*/
if ((period = (currtime - lasttime) / 1000000) <= 0)
period = 1;
/*
* Calculate new per/period values for statistics
*/
Elapsed_Time += period;
/*
* Display new statistics
*/
prheading(++count);
if (mirror_sw) {
if (dual_stats() < 0)
mirror_sw = 0;
} else if (toggle_total_sw)
total_display();
else
display_cache();
(void) move(0, 0);
(void) refresh();
if (logfd > -1) wrefresh_file(stdscr, logfd);
FD_ZERO(&readfds);
FD_SET(fd, &readfds);
tout.tv_sec = delay;
for (;;) {
tout.tv_usec = 0;
if (select(fd + 1, &readfds, (fd_set *)0, (fd_set *)0,
&tout) <= 0)
break;
if ((c = getch()) == EOF) {
(void) sleep(delay);
break;
}
checkbuf(c);
tout.tv_sec = 0;
}
(void) erase();
}
#pragma error_messages(off, E_STATEMENT_NOT_REACHED)
return (0);
#pragma error_messages(default, E_STATEMENT_NOT_REACHED)
}
void opt_sim(struct memory_reference *instructions, uint32_t count, uint32_t *pt, int pages, int frames)
{
struct opt_node * references;
references = malloc((1 << 20) * sizeof(struct opt_node));
memset(references, 0, (1 << 20) * sizeof(struct opt_node));
char line_buffer[30];
unsigned int instruction;
instruction = 0;
uint32_t page_number;
struct opt_page valid_pages[frames];
uint32_t i, k;
int j, index;
int next_frame;
int max;
for(i = 0; i < frames; i++){
valid_pages[i].page_number = NOTHING_TO_SEE_HERE;
}
struct memory_reference current = instructions;
for(i = 0; i < count; i++){
index = -1;
page_number = instructions[i].address >> 12;
// search for page in frame table. if it's not there, we need to add it.
for(j = 0; j < next_frame; j++){
if(page_number == valid_pages[j].page_number){
index = j;
}
}
if(index < 0){
// we did not find the page in our frames, add it
if(next_frame == frames){
max = 0;
// if we are full, we need to swap
for(j = 0; j < next_frame; j++){
if(valid_pages[j].next_reference > valid_pages[max].next_reference){
max = j;
} else if(valid_pages[j].next_reference == valid_pages[max].next_reference){
if(!is_dirty(pt[valid_pages[max].page_number])){
max = j;
}
}
} // now we have the page to evict
if(is_dirty(pt[valid_pages[max].page_num])){
printf("page fault - evict dirty\n");
// increase disk write counter
} else {
printf("page fault - evict clean\n");
}
valid_pages[max].page_number = page_number;
valid_pages[max].next_reference = find_next_reference(instructions, count, i);
// update page table
} else {
valid_pages[next_frame].page_number = page_number; // no eviction
valid_pages[next_frame].next_reference = find_next_reference(instructions, count, i);
printf("page fault - no eviction\n");
next_frame++;
}
} else {
printf("hit\n");
}
}
// keep a list of instruction numbers for each page
//
}
virtual bool needs_update() { return ((_w>0)&&(_h>0)&&is_dirty()&&(_list.num()>0)); }
