BOOL8 pmt_cache_evict()
{
if (!pmt_cache_is_full()) return 0;
while (merge_buf_size < SUB_PAGES_PER_PAGE) {
UINT32 lru_page_idx = mem_search_min_max(
cached_pmt_timestamps,
sizeof(UINT32),
NUM_PC_SUB_PAGES,
MU_CMD_SEARCH_MIN_SRAM);
ASSERT(lru_page_idx < NUM_PC_SUB_PAGES);
ASSERT(cached_pmt_idxes[lru_page_idx] < PMT_SUB_PAGES);
ASSERT(cached_pmt_timestamps[lru_page_idx] < NULL_TIMESTAMP);
BOOL8 is_dirty = bit_array_test(cached_pmt_is_dirty, lru_page_idx);
if (!is_dirty) {
free_page(lru_page_idx);
return 0;
}
if (lru_page_idx == last_page_idx) {
last_page_idx = NULL_PAGE_IDX;
last_pmt_idx = NULL_PMT_IDX;
}
cached_pmt_timestamps[lru_page_idx] = EVICTED_TIMESTAMP;
merged_page_idxes[merge_buf_size] = lru_page_idx;
merge_buf_size++;
}
return 1;
}
static void dma_si_write(struct si_controller* si)
{
int i;
if (si->regs[SI_PIF_ADDR_WR64B_REG] != 0x1FC007C0)
{
DebugMessage(si->r4300->state, M64MSG_ERROR, "dma_si_write(): unknown SI use");
si->r4300->state->stop=1;
}
for (i = 0; i < PIF_RAM_SIZE; i += 4)
{
*((uint32_t*)(&si->pif.ram[i])) = sl(si->ri->rdram.dram[(si->regs[SI_DRAM_ADDR_REG]+i)/4]);
}
if (si->r4300->state->enable_trimming_mode)
{
for (i = 0; i < PIF_RAM_SIZE; i += 4)
{
unsigned int ram_address = si->regs[SI_DRAM_ADDR_REG] + i;
if (!bit_array_test(si->r4300->state->barray_ram_written_first, ram_address / 4))
bit_array_set(si->r4300->state->barray_ram_read, ram_address / 4);
}
}
update_pif_write(si);
update_count(si->r4300->state);
if (si->r4300->state->g_delay_si) {
add_interupt_event(si->r4300->state, SI_INT, /*0x100*/0x900);
} else {
si->regs[SI_STATUS_REG] |= 0x1000; // INTERRUPT
signal_rcp_interrupt(si->r4300, MI_INTR_SI);
}
}
int create_block_reservation(int blocks_needed) {
// Finds an area of free blocks in our database file.
int i,j;
bool found = false;
int retval = -1;
sem_wait(BLOCK_BITMAP_LOCK);
for (j = 0; j < MAX_BLOCKS; j++) {
for (i = 0; i < blocks_needed; i++) {
if (bit_array_test(SHM_BLOCK_BITMAP, i + j) != 0) {// didn't find a contiguous block
j += i;
break;
}
}
if (i == blocks_needed) {
found = true;
break;
}
}
if (found) {
for (i = 0; i < blocks_needed; i++) // Found a good set of blocks. Mark them as used.
bit_array_set(SHM_BLOCK_BITMAP, i + j);
retval = j;
}
msync(SHM_BLOCK_BITMAP, BLOCK_BITMAP_BYTES, MS_SYNC); // commit the whole block bitmap to disk
sem_post(BLOCK_BITMAP_LOCK);
return(retval);
}
BOOL8 pmt_cache_is_dirty(UINT32 const pmt_idx)
{
UINT32 page_idx = get_page(pmt_idx);
ASSERT(page_idx != NULL_PAGE_IDX);
BOOL8 is_dirty = bit_array_test(cached_pmt_is_dirty, page_idx);
return is_dirty;
}
void hash_write_lock(int hash_number) {
while (1) {
sem_wait(HASHBUCKET_LOCK);
if ((bit_array_test(SHM_HASHBUCKET_BITMAP, hash_number)) == 0) {
bit_array_set(SHM_HASHBUCKET_BITMAP, hash_number);
sem_post(HASHBUCKET_LOCK);
break;
}
sem_post(HASHBUCKET_LOCK);
}
}
void* socketHandler(struct SHArgs *shargs) {
int *clientSocket = shargs->clientSocket;
bit_array_t *bits = shargs->bits;
int packetLen = 5;
int byteCount;
struct message msg;
struct message rsp;
char read_char = 'r';
char set_char = 's';
char unset_char = 'u';
char error_char = 'e';
while ((byteCount = recv(*clientSocket, &msg, 5, 0)) > 0) {
/* printf("got data\n"); */
rsp.offset = msg.offset;
rsp.val = error_char;
if (msg.val == read_char) {
/* printf("read\n"); */
if(bit_array_test(bits, msg.offset)) {
rsp.val = set_char;
} else {
rsp.val = unset_char;
}
} else if (msg.val == set_char){
/* printf("set\n"); */
bit_array_set_true(bits, msg.offset);
rsp.val = set_char;
} else if (msg.val == unset_char) {
/* printf("unset\n"); */
bit_array_set_false(bits, msg.offset);
rsp.val = unset_char;
} else {
/* printf("recieved malformed action.\n"); */
}
send(*clientSocket, &rsp, packetLen, 0);
}
shutdown(*clientSocket, SHUT_WR);
close(*clientSocket);
free(clientSocket);
printf("Lost a connection.\n");
return NULL;
}
void keydb_lock(int64_t pos) {
char key[1024] = "";
int hash_number;
sprintf(key, "%llu", pos); // turn pos into a string.
hash_number = get_hash_val(10, key); // 2^10 = 1024. See SHM_KEYDB_BITMAP.
while (1) {
sem_wait(KEYDB_LOCK);
if ((bit_array_test(SHM_KEYDB_BITMAP, hash_number)) == 0) {
bit_array_set(SHM_KEYDB_BITMAP, hash_number);
sem_post(KEYDB_LOCK);
break;
}
sem_post(KEYDB_LOCK);
}
}
