int RecordManager::select_record(char* tableName, Node* def, Node* expr, vector<CursePair>& curseTable)
{
string filename(tableName);
filename+=".db";
load_file(filename);
assignColumnName(def);
unsigned char* block = nullptr;
// from start to column
int initial_offset = m_header.valLength;
int columnId = 0;
for (int i = m_header.columnCount - 1; i >=0 ;--i)
{
initial_offset -= m_header.columnLength[i];
if (strcmp(m_header.columnName[i], expr->leftSon->strval) == 0)
{
columnId = i;
// always break!
break;
}
}
for (auto it=curseTable.begin(); it!=curseTable.end();)
{
block = m_bufInstance->getblock(m_currentPage, it->first, BUFFER_FLAG_NONDIRTY)\
+ it->second + initial_offset;
if (!cmpExpr(expr, block, columnId))
curseTable.erase(it);
else
++it;
}
write_back();
return 0;
}
int main(int argc, char* argv[]){
if(argc == 5){
request.siz = atoi(argv[3]);
request.beg = atoi(argv[2]);
if(argv[4][0] == 'b'){
isWorst = false;
}else{
isWorst = true;
}
}else if(argc == 4){
request.siz = atoi(argv[2]);
request.beg = -1;
printf("!\n");
if(argv[3][0] == 'b'){
isWorst = false;
}else{
isWorst = true;
}
}else{
printf("EX0: match.exe free 12 20 b(release 20 bytes, begin at 12, using best-matching).\nEX1: match.exe malloc 28 w(allocate 28 bytes, using worst-matching)\n");
exit(0);
}
int begin, size;
Node* p = &head;
FILE* in;
if(!(in = fopen("stats.txt", "r"))){
printf("Fail to acquire memory States!\n");
}
while(~fscanf(in, "%d %d", &begin, &size)){
printf("%d %d\n", begin, size);
Node* newNode = new Node();
p->nxt = newNode;
p->beg = begin;
p->siz = size;
newNode->beg = -1;
newNode->siz = 0;
newNode->nxt = NULL;
p = p->nxt;
blocks ++;
}
fclose(in);
printf("We get:\n");
show_list();
if(request.beg != -1){
free_mem();
}else if(isWorst){
malloc_worst();
}else{
malloc_best();
}
printf("Current Mem-states:\n");
show_list();
write_back();
return 0;
}
/* Returns an unoccupied block and acquires its lock as a writer */
struct cached_block *
get_free_block(void)
{
lock_acquire(&fs_evict_lock);
while(true)
{
struct cached_block *cb = &fs_cache[fs_cache_arm];
fs_cache_arm = (fs_cache_arm + 1) % CACHE_BLOCKS;
if (writer_try_acquire(&cb->rw_lock)) {
ASSERT (cb->state != IN_IO);
if (cb->state == UNOCCUPIED) {
lock_release(&fs_evict_lock);
return cb;
}
if (cb->accessed == false) {
lock_release(&fs_evict_lock);
write_back(cb);
cb->state = UNOCCUPIED;
return cb;
}
cb->accessed = false;
writer_release(&cb->rw_lock);
}
}
}
int main( int argc, char **argv ){
// Init the instructions
init_instr_memory();
// CLOCK CYCLE LOOP
int instr_buffer;
while( 1 ){
// NOTE: Order matters. All functions should fetch value
// from pipelined reg before the previous stage override the
// reg values
write_back();
memory_write();
execute_2();
execute_1();
instruction_decode();
instruction_fetch();
clk++;
}
free( instruction_memory );
free( data_memory );
exit( 0 );
}
int main (int argc, char **argv) {
parse_args (argc, argv);
parse_file (inst_defn_file, 'd');
parse_file (inst_trace_file, 't');
create_arch();
while (instr_proc < instr_count) {
cycles++;
issue ();
execute ();
write_back();
}
finish ();
return 0;
}
/**
* Remove cached entry for key, optionally disposing of the whole structure.
* Cached entry is flushed if it was dirty and flush is set.
*
* @return the reusable cached entry if dispose was FALSE and the key was
* indeed cached, NULL otherwise.
*/
static struct cached *
remove_entry(dbmw_t *dw, gconstpointer key, gboolean dispose, gboolean flush)
{
struct cached *old;
gpointer old_key;
gboolean found;
found = map_lookup_extended(dw->values, key, &old_key, (gpointer) &old);
if (!found)
return NULL;
g_assert(old != NULL);
if (old->dirty && flush)
write_back(dw, key, old);
hash_list_remove(dw->keys, key);
map_remove(dw->values, key);
wfree(old_key, dbmw_keylen(dw, old_key));
if (!dispose)
return old;
/*
* Dispose of the cache structure.
*/
free_value(dw, old, TRUE);
WFREE(old);
return NULL;
}
int RecordManager::delete_all_record(char* tableName)
{
// unlike delete select,
// it just clear all
string filename(tableName);
filename+=".db";
load_file(filename);
unsigned char* block = nullptr;
for (int i = m_header.blockCount-1; i > 0; --i)
{
block = m_bufInstance->getblock(m_currentPage, i, BUFFER_FLAG_DIRTY);
memset(block, 0, sizeof(char)*BLOCK_SIZE);
}
block = m_bufInstance->getblock(m_currentPage, 0, BUFFER_FLAG_DIRTY);
memset(block+m_header.headerLength, 0, sizeof(char)*(BLOCK_SIZE - m_header.headerLength));
// TO-DO, rewrite header
int returnVal = m_header.entryCount;
m_header.blockCount = 1;
m_header.entryCount = 0;
m_header.nextEmptyNo = 0;
m_header.nextEmptyOffset = m_header.headerLength;
write_back();
return returnVal;
}
struct execution_result executor_instruction_execute(uint8_t *instruction, size_t instruction_length,
struct tracking_trace *trace, struct context *context, void *code, struct tbgen_result tbgen_result) {
result.type = EXECUTION_RTYPE_SUCCESS;
struct stack *mappings = stack_init();
char retval = map_and_copy(mappings, trace, context, tbgen_result);
if(retval) {
result.type = EXECUTION_RTYPE_MAPPING_ERROR;
goto unmap_all;
}
struct sigaction act;
memset(&act, 0, sizeof(act));
act.sa_sigaction = sighandler;
act.sa_flags = SA_SIGINFO;
sigaction(SIGSEGV, &act, NULL);
sigaction(SIGILL, &act, NULL);
sigaction(SIGALRM, &act, NULL);
sigaction(SIGBUS, &act, NULL);
sigaction(SIGFPE, &act, NULL);
sigaction(SIGSYS, &act, NULL);
sigaction(SIGTRAP, &act, NULL);
// alarm(1);
// __asm__ ("mov $0x00112244556677, %rsi\nbtc %ax, (%rsi)\n");
#ifndef DRYRUN
if(!setjmp(jbuf))
((void (*)(void))code)();
else
result.type = EXECUTION_RTYPE_SIGNAL;
#endif
alarm(0);
act.sa_sigaction = NULL;
sigaction(SIGSEGV, &act, NULL);
sigaction(SIGILL, &act, NULL);
sigaction(SIGALRM, &act, NULL);
sigaction(SIGBUS, &act, NULL);
sigaction(SIGFPE, &act, NULL);
sigaction(SIGSYS, &act, NULL);
sigaction(SIGTRAP, &act, NULL);
write_back(trace, context);
unmap_all: unmap_all(mappings);
stack_free(mappings);
executor_virt_calc(context);
return result;
}
int main(){
init();
/* reset_disk(); */
/* dir_test(); */
/* file_test(); */
show_file_list();
/* read_write_test(); */
/* rename_test(); */
write_back();
}
catalog * catalog_manager::add_relation(create_table_stmt *tmp) {
if (relations.count(tmp->name) == 1)
throw invalid_argument("Table already exsists.");
auto new_catalog = new catalog(tmp);
relations[tmp->name] = new_catalog;
// mkdir and write back
mkdir((new_catalog->get_name()).c_str(), 0777);
// TODO exception handler
new_catalog->write_back((new_catalog->get_name()));
return new_catalog;
}
/**
* Map iterator to flush dirty cached entries.
*/
static void
flush_dirty(gpointer key, gpointer value, gpointer data)
{
struct flush_context *ctx = data;
struct cached *entry = value;
if (entry->dirty) {
if (!entry->absent && ctx->deleted_only)
return;
if (write_back(ctx->dw, key, entry))
ctx->amount++;
else
ctx->error = TRUE;
}
}
int Simulator::simulate(){
load_i_cache();
load_d_cache();
print_d_cache();
print_i_cache();
while(1){
out.open("ins_pipeline.txt",ios::out);
fetch(ins_index[0]);
decode(ins_index[1]);
register_read(ins_index[2]);
execute(ins_index[3]);
mem_branch_cycle(ins_index[4]);
if (!write_back(ins_index[5])) {
cout << "Simulation Ends!" << endl;
break;
}
if(unset_raw_flag_cycle) {
unset_raw_flag_cycle = false;
if (!control_flag && !prev_raw_flag) {
ins_pipeline[ins_index[0]] = temp_fetch;
}
prev_raw_flag = false;
ins_pipeline[ins_index[1]] = temp_decode;
}
if(branch_pred_enabled) {
if (flush_pipeline) {
flush();
}
}
out << (m_clk + 1) << endl;
out.close();
system ("python gui.py");
next_clock_cycle();
//print_reg_file();
}
print_d_cache();
printf("clk cycles = %lld\n",m_clk + 1);
printf("CPI = %f\n",1.0*(m_clk + 1)/num_ins_executed);
printf("Stalls = %lld\n",num_stalls - 5);
if (!branch_pred_enabled){
printf("Control Stalls = %lld\n",num_control_stalls);
printf("RAW Stalls = %lld\n",num_stalls - 5 - num_control_stalls);
}
return 1;
}
int RecordManager::select_record_raw(char* tableName, Node* def, Node* expr, vector<CursePair>& curseTable)
{
string filename(tableName);
filename+=".db";
load_file(filename);
assignColumnName(def);
// from flag back to column
int initial_offset = 0;
int columnId = 0;
for (int i = m_header.columnCount - 1; i >=0 ;--i)
{
initial_offset += m_header.columnLength[i];
if (strcmp(m_header.columnName[i], expr->leftSon->strval) == 0)
{
columnId = i;
// always break!
break;
}
}
// all
int blockNo = 0;
unsigned char* block = m_bufInstance->getblock(m_currentPage, blockNo, BUFFER_FLAG_NONDIRTY);
unsigned char* blockPtr = block+m_header.headerLength+m_header.valLength;
for (int i = m_header.entryCount; i>0;)
{
if (*(int*)blockPtr < 0)
{
--i;
if (cmpExpr(expr, blockPtr - initial_offset, columnId))
curseTable.push_back(std::make_pair(blockNo, blockPtr-block-m_header.valLength));
}
blockPtr += (m_header.valLength+sizeof(int));
if ((blockPtr+sizeof(int)) > (block+BLOCK_SIZE))
{
block = m_bufInstance->getblock(m_currentPage, ++blockNo, BUFFER_FLAG_NONDIRTY);
blockPtr = block+m_header.valLength;
}
}
write_back();
return 0;
}
void process_instruction(){
// update stage
write_back();
if( if_register.stall == 0 ) {
instruction_fetch();
} else {
if_register.stall += -1;
}
instruction_decode();
execute_instruction();
memory_access();
btb_move_right();
int index = (CURRENT_STATE.PC - MEM_TEXT_START - 4)/4 ;
// printf(" index %d, NUM_INST %d \n",index,NUM_INST);
if( index == NUM_INST ) {
CURRENT_STATE.PC += -4;
// printf("Run bit unset pc: %x\n",CURRENT_STATE.PC);
}
}
/* Write all of the cached blocks back to disk. */
void
write_back_all(void)
{
/* XXX: Hard-coded 64 cache blocks */
uint64_t wrote_back = 0;
int i;
while (wrote_back != UINT64_MAX) {
for (i = 0; i < 64; i++) {
struct cached_block *cb = &fs_cache[i];
if ((wrote_back & (1 << i)) == 0) {
if (writer_try_acquire(&cb->rw_lock)) {
write_back(cb);
wrote_back |= (1 << i);
writer_release(&cb->rw_lock);
}
}
}
}
}
int git_object_write(git_object *object)
{
int error;
git_odb_source *source;
assert(object);
if (object->modified == 0)
return GIT_SUCCESS;
prepare_write(object);
source = &object->source;
switch (source->raw.type) {
case GIT_OBJ_COMMIT:
error = git_commit__writeback((git_commit *)object, source);
break;
case GIT_OBJ_TREE:
error = git_tree__writeback((git_tree *)object, source);
break;
case GIT_OBJ_TAG:
error = git_tag__writeback((git_tag *)object, source);
break;
case GIT_OBJ_BLOB:
error = git_blob__writeback((git_blob *)object, source);
break;
default:
error = GIT_ERROR;
break;
}
if (error < GIT_SUCCESS) {
git_object__source_close(object);
return error;
}
return write_back(object);
}
/**
* Write data to disk immediately.
*/
static void
write_immediately(dbmw_t *dw, gconstpointer key, gpointer value, size_t length)
{
struct cached tmp;
tmp.data = value;
tmp.len = length;
tmp.dirty = TRUE;
tmp.absent = FALSE;
write_back(dw, key, &tmp);
/*
* Free any dynamically allocated memory in the value, through
* registered value cleanup callback.
*/
if (length && dw->valfree)
(*dw->valfree)(value, length);
}
/**
* Remove cached entry for key, optionally disposing of the whole structure.
* Cached entry is flushed if it was dirty and flush is set.
*
* @return the reusable cached entry if dispose was FALSE and the key was
* indeed cached, NULL otherwise.
*/
static struct cached *
remove_entry(dbmw_t *dw, const void *key, bool dispose, bool flush)
{
struct cached *old;
void *old_key;
bool found;
found = map_lookup_extended(dw->values, key, &old_key, (void *) &old);
if (!found)
return NULL;
g_assert(old != NULL);
if (dbg_ds_debugging(dw->dbg, 3, DBG_DSF_CACHING)) {
dbg_ds_log(dw->dbg, dw, "%s: %s key=%s (%s)",
G_STRFUNC, old->dirty ? "dirty" : "clean",
dbg_ds_keystr(dw->dbg, key, (size_t) -1),
flush ? "flushing" : " discarding");
}
if (old->dirty && flush)
write_back(dw, key, old);
hash_list_remove(dw->keys, key);
map_remove(dw->values, key);
wfree(old_key, dbmw_keylen(dw, old_key));
if (!dispose)
return old;
/*
* Dispose of the cache structure.
*/
free_value(dw, old, TRUE);
WFREE(old);
return NULL;
}
void run_armsim()
{
while(ex_flag!=1)
{
b_flag=0;
fetch();
decode();
execute();
if(ex_flag==1)
{return ;}
//if(control==17&&u==5) //////////
// return; /////////////
if(b_flag==1)
continue;
mem();
write_back();
}
return;
}
// maxProgress >=0, <= 1; ==2;
void affine_propagator::prune(const affine r[],
affine vars[],
const int num_of_vars,
bool& toDelete,
double& maxProgress)
{
assert ( num_of_vars == n_vars ) ;
maxProgress = 0.0;
if (!affine::isValid) {
//cout << "Deleted" << endl;
toDelete = true;
return;
}
reset_arrays();
bool to_discard = process_all_eqs(r, vars, maxProgress);
if (to_discard) {
affine::isValid = false;
toDelete = true;
return;
}
if (!check_for_zero(r, 0, n_vars-1)) {
//cout << "Deleted" << endl;
affine::isValid = false;
toDelete = true;
return;
}
bool has_changed = write_back(vars, maxProgress);
if (!has_changed)
maxProgress = 0.0;
}
int RecordManager::delete_record(char* tableName, vector<CursePair>& curseTable)
{
string filename(tableName);
filename+=".db";
load_file(filename);
m_header.entryCount -= curseTable.size();
unsigned int blockFlag = (m_header.nextEmptyNo<<BLOCK_NUMBER_OFFSET)\
|m_header.nextEmptyOffset;
for (auto it:curseTable)
{
unsigned char* block=m_bufInstance->getblock(m_currentPage, it.first, 1);
*(unsigned int*)(block+it.second+m_header.valLength) = blockFlag;
blockFlag = (it.first<<BLOCK_NUMBER_OFFSET)|(it.second);
}
m_header.nextEmptyOffset = blockFlag&BLOCK_SIZE_MASK;
m_header.nextEmptyNo = (blockFlag>>BLOCK_NUMBER_OFFSET)&BLOCK_NUMBER_MASK;
write_back();
return curseTable.size();
}
int main(){
int i=0;
initialize();
//cycle0
if(test==1) printf(">>cycle %d\n",cycle);
instruction_fetch(1);
initial_SNAP();
//cycle1
if(test==1) printf(">>cycle %d\n",cycle);
instruction_decode(ID_index);
instruction_fetch(1);
append_SNAP();
//cycle2
if(test==1) printf(">>cycle %d\n",cycle);
execution(EX_index);
instruction_decode(ID_index);
instruction_fetch(1);
append_ERROR();
if(halt==1 || halt_count==5){
return 0;
}
append_SNAP();
if(stall){
memory(DM_index);
execution(0);
instruction_decode(0);
//instruction_fetch(0);
append_ERROR();
if(halt==1 || halt_count==5) return 0;
stall=0;
append_SNAP();
}
if(flush){
flush=0;
}
//cycle3
if(test==1) printf(">>cycle %d\n",cycle);
memory(DM_index);
execution(EX_index);
instruction_decode(ID_index);
instruction_fetch(1);
append_ERROR();
if(halt==1 || halt_count==5){
return 0;
}
append_SNAP();
if(stall){
write_back(WB_index);
memory(DM_index);
execution(0);
instruction_decode(0);
//instruction_fetch(0);
append_ERROR();
if(halt==1 || halt_count==5) return 0;
stall=0;
append_SNAP();
}
if(flush){
flush=0;
}
while(i<50){
i++;
if(test==1) printf(">>cycle %d\n",cycle);
write_back(WB_index);
memory(DM_index);
execution(EX_index);
instruction_decode(ID_index);
instruction_fetch(1);
append_ERROR();
if(halt==1 || halt_count==5){
break;
}
append_SNAP();
if(stall){
write_back(WB_index);
memory(DM_index);
execution(0);
instruction_decode(0);
//instruction_fetch(0);
append_ERROR();
if(halt==1 || halt_count==5) return 0;
stall=0;
append_SNAP();
}
if(flush){
flush=0;
}
}
return 0;
}
/*main*/
void HariMain(void){
fs_pid=get_pid();
while(identify_hd()==FALSE);
while(identify_fs()==FALSE);//读取superBlock
/*如果硬盘上不存在文件系统，则新建一个。注：约定tinyOS文件系统的superBlock前5字节为字符串“TINY”*/
if(strcmp(superBlock.sign,"TINY")==FALSE)
{
create_fs();
identify_fs();/*因为之前读取的可能无效，当文件系统不存在时*/
}
read_hd_bmp ();
read_fat();
while(1)
{
receive(&msg_recv,STATUS_RECV_ANY,0,fs_pid);
u_int32 recv_type=msg_recv.type;
u_int32 send_pid =msg_recv.send_pid;
switch(recv_type)
{
case FILE_MSG_TYPE:
{
struct FILE_MSG *msg =&msg_recv.u.msg_file;
u_int32 file_msg_type=msg->type ;
int8*file_name =msg->file_name ;
void*buf =msg->buf ;
u_int32 buf_len =msg->buf_len ;
u_int32 handle =msg->handle ;
u_int32 result ;
struct I_NODE*inode =msg->inode ;
switch(file_msg_type)
{
case FILE_IDENTIFY:
if(identify_file(handle,inode,send_pid)==TRUE )
awake(send_pid,TRUE );
else
awake(send_pid,FALSE );
break;
case FILE_OPEN :
handle=open_file(file_name,send_pid);
awake(send_pid,handle);
break;
case FILE_READ :
if((result=read_file(handle,buf_len,buf,send_pid))!=FALSE)
awake(send_pid,result );
else
awake(send_pid,FALSE );
break;
case FILE_WRITE :
if(write_file(handle,buf_len,buf,send_pid)==TRUE )
awake(send_pid,TRUE );
else
awake(send_pid,FALSE);
break;
case FILE_CREATE :
if(create_file(file_name,send_pid)==TRUE )
awake(send_pid,TRUE );
else
awake(send_pid,FALSE);
break;
case FILE_DELETE :
if(delete_file(handle,send_pid)==TRUE )
awake(send_pid,TRUE );
else
awake(send_pid,FALSE );
break;
case POWER_OFF :
write_back( );
awake(send_pid,TRUE );
break;
default:
awake(send_pid,FALSE );
break;
}
break;
}
default:
break;
}
}
}
//--------------------------------------------------------------------
// void execute(instr *i)
//
// execute consists of the following tasks:
// - fetch the operands
// - execute the operation in the intruction
// - write the data back in the destination
// - compute the next address for (jmp, call, return...)
//
//--------------------------------------------------------------------
void cycle_model::execute(instr *i) {
int in1, in2, out = 0;
// fetch operands ---------------------------------------------------
if(i->n_src>=1)
in1 = fetch_operand(&(i->src1));
if(i->n_src>=2)
in2 = fetch_operand(&(i->src2));
#ifdef DEBUG
printf("execute %d, with in1=%d and in2=%d\n",i->type,in1, in2);
#endif
// execute ----------------------------------------------------------
switch(i->type) {
case i_add: {
out = in1 + in2;
break;
}
case i_sub: {
out = in1 - in2;
break;
}
case i_inc: {
out = in1+1;
break;
}
case i_dec: {
out = in1-1;
break;
}
case i_mul: {
out = in1 * in2;
break;
}
case i_div: {
out = in1/in2;
break;
}
// logic operations
case i_and: {
out = in1 & in2;
break;
}
case i_or: {
out = in1 | in2;
break;
}
case i_xor: {
out = in1 ^ in2;
break;
}
case i_rl: {
out = in1<<1;
break;
}
case i_rr: {
out = in2>>1;
break;
}
// data transfer
case i_mov: {
out = in1;
break;
}
// branching (out==0 -> don't branch)
case i_call:
case i_ret:
case i_jmp:
case i_sjmp: {
out = 1;
break;
}
case i_jz: {
out = (A==0);
break;
}
case i_jnz: {
out = (A!=0);
break;
}
case i_cjne: {
out = (in1!=in2);
break;
}
case i_djnz: {
out=in1-1; // decrement reg/direct and jump if != 0
break;
}
default: {
break;
}
}
// write back --------------------------------------------------------
write_back(&(i->dst),out);
// compute next address ----------------------------------------------
switch(i->type) {
case i_call: {
stack_el *new_stack_el= (stack_el *) malloc(sizeof(stack_el));
new_stack_el->up = my_stack;
new_stack_el->address = in1;
my_stack = new_stack_el;
/* wait additional cycles */
int result;
exec_bus_cycle(OP_IDLE,0,0,&result);
break;
}
case i_ret: {
stack_el *new_stack_el = my_stack->up;
free(my_stack);
my_stack = new_stack_el;
if(my_stack!=NULL)
my_stack->address += 1; // increment address after jump
/* wait additional cycles */
int result;
exec_bus_cycle(OP_IDLE,0,0,&result);
exec_bus_cycle(OP_IDLE,0,0,&result);
exec_bus_cycle(OP_IDLE,0,0,&result);
break;
}
case i_jmp: {
my_stack->address = in1;
/* wait additional cycles */
int result;
exec_bus_cycle(OP_IDLE,0,0,&result);
break;
}
case i_sjmp:
case i_jz:
case i_jnz: {
if(out!=0)
my_stack->address += in1+1;
else
my_stack->address += 1;
/* wait additional cycles */
int result;
exec_bus_cycle(OP_IDLE,0,0,&result);
break;
}
case i_cjne: {
int in3 = fetch_operand(&i->dst);
if(out!=0)
my_stack->address += in3+1;
else
my_stack->address += 1;
/* wait additional cycles */
int result;
exec_bus_cycle(OP_IDLE,0,0,&result);
break;
}
case i_djnz: {
if(out!=0)
my_stack->address += in2+1;
else
my_stack->address += 1;
/* wait additional cycles */
int result;
exec_bus_cycle(OP_IDLE,0,0,&result);
break;
}
default: {
my_stack->address += 1;
break;
}
}
}
//public
CursePair RecordManager::new_entry_record(Node* root)
{
string filename(root->strval);
filename+=".db";
load_file(filename);
unsigned char* blockEmpty;
if (m_header.nextEmptyNo >= m_header.blockCount)
{
blockEmpty = m_bufInstance->newblock(m_currentPage, BUFFER_FLAG_DIRTY);
m_header.blockCount++;
}
else
{
blockEmpty = m_bufInstance->getblock(m_currentPage, m_header.nextEmptyNo, BUFFER_FLAG_DIRTY);
}
int blockNo = m_header.nextEmptyNo;
int blockOffset = m_header.nextEmptyOffset;
unsigned char* ptrBuf = blockEmpty+blockOffset+m_header.valLength;
Node* ptrData = root->leftSon;
int blockFlag = *(int*)ptrBuf;
assert(blockFlag>=0);
if (blockFlag == 0)
{
// initially empty
// need new block
if (m_header.nextEmptyOffset+(m_header.valLength+sizeof(int))*2\
> BLOCK_SIZE)
{
++m_header.nextEmptyNo;
m_header.nextEmptyOffset = 0;
}
else
{
m_header.nextEmptyOffset += m_header.valLength+sizeof(int);
}
}
else //if (blockFlag > 0)
{
// deleted
m_header.nextEmptyOffset = blockFlag&BLOCK_SIZE_MASK;
m_header.nextEmptyNo = (blockFlag>>BLOCK_NUMBER_OFFSET)&BLOCK_NUMBER_MASK;
}
// make flag empty?
*(unsigned int*)ptrBuf = 0x80000000;
++m_header.entryCount;
for (int i = m_header.columnCount - 1; i >= 0; --i)
{
size_t len = m_header.columnLength[i];
ptrBuf -= len;
// Warning! maybe some bugs
if (m_header.columnType[i] == VAL_CHAR)
strncpy((char*)ptrBuf, ptrData->strval,len);
else if (m_header.columnType[i] == VAL_FLOAT)
{
*((float*)ptrBuf) = (float)ptrData->numval;
}
else //(m_header.columnType == VAL_INT)
{
*((int*)ptrBuf) = (int)ptrData->numval;
}
ptrData = ptrData->leftSon;
}
write_back();
return std::make_pair(blockNo, blockOffset);
}
int RecordManager::print_all_record(char* tableName, Node* def)
{
string filename(tableName);
filename+=".db";
load_file(filename);
assignColumnName(def);
int* tableLen = new int[m_header.columnCount];
for (int i = m_header.columnCount-1; i >=0 ; --i)
{
int maxlen = strlen(m_header.columnName[i]);
if (m_header.columnType[i] == VAL_INT)
maxlen = (maxlen > 11) ? maxlen : 11;
else if (m_header.columnType[i] == VAL_FLOAT)
maxlen = (maxlen > 8) ? maxlen : 8;
else
maxlen = (maxlen > m_header.columnLength[i]) ? maxlen : m_header.columnLength[i];
tableLen[i] = maxlen;
}
// print title
printBorder(tableLen, m_header.columnCount);
// print column name
for (int i = 0; i < m_header.columnCount; ++i)
{
putchar('|');
cout.width(tableLen[i]);
cout <<m_header.columnName[i];
}
putchar('|');
putchar('\n');
printBorder(tableLen, m_header.columnCount);
// print data
// TO-DO test
int blockNo = 0;
unsigned char* blockHead = m_bufInstance->getblock(m_currentPage, 0, BUFFER_FLAG_NONDIRTY);
unsigned char* blockPtr = blockHead + m_header.headerLength;
unsigned char* blockFlagPtr = blockPtr + m_header.valLength;
for (int j = m_header.entryCount; j > 0;)
{
if (*(int*)blockFlagPtr < 0)
{
for (int i = 0; i < m_header.columnCount; ++i)
{
putchar('|');
cout.width(tableLen[i]);
if (m_header.columnType[i] == VAL_CHAR)
{
cout <<blockPtr;
}
else if (m_header.columnType[i] == VAL_FLOAT)
{
cout <<*(float*)blockPtr;
}
else
{
cout <<*(int*)blockPtr;
}
blockPtr += m_header.columnLength[i];
}
putchar('|');
putchar('\n');
--j;
}
blockPtr = (blockFlagPtr+sizeof(int));
blockFlagPtr += (m_header.valLength+sizeof(int));
if ((blockPtr) > (blockHead+BLOCK_SIZE))
{
blockHead = m_bufInstance->getblock(m_currentPage, ++blockNo, BUFFER_FLAG_NONDIRTY);
blockPtr = blockHead;
blockFlagPtr = blockHead + m_header.valLength;
}
}
printBorder(tableLen, m_header.columnCount);
delete [] tableLen;
write_back();
return 0;
}
int RecordManager::print_select_record(char* tableName, Node* def, vector<CursePair>& curseTable)
{
string filename(tableName);
filename+=".db";
load_file(filename);
assignColumnName(def);
// print title
int* tableLen = new int[m_header.columnCount];
for (int i = 0; i < m_header.columnCount; ++i)
{
int maxlen = strlen(m_header.columnName[i]);
if (m_header.columnType[i] == VAL_INT)
maxlen = (maxlen > 10) ? maxlen : 10;
else if (m_header.columnType[i] == VAL_FLOAT)
maxlen = (maxlen > 8) ? maxlen : 8;
else
maxlen = (maxlen > m_header.columnLength[i]) ? maxlen : m_header.columnLength[i];
tableLen[i] = maxlen;
}
// TO-DO
// print title
printBorder(tableLen, m_header.columnCount);
// print column name
for (int i = 0; i < m_header.columnCount; ++i)
{
putchar('|');
cout.width(tableLen[i]);
cout <<m_header.columnName[i];
}
putchar('|');
putchar('\n');
printBorder(tableLen, m_header.columnCount);
// print data
for (auto it:curseTable)
{
unsigned char* blockPtr =m_bufInstance->getblock(m_currentPage, it.first,BUFFER_FLAG_NONDIRTY)+it.second;
for (int i = 0; i < m_header.columnCount; ++i)
{
putchar('|');
cout.width(tableLen[i]);
if (m_header.columnType[i] == VAL_CHAR)
{
cout <<blockPtr;
}
else if (m_header.columnType[i] == VAL_FLOAT)
{
cout <<*(float*)blockPtr;
}
else
{
cout <<*(int*)blockPtr;
}
blockPtr += m_header.columnLength[i];
}
putchar('|');
putchar('\n');
}
printBorder(tableLen, m_header.columnCount);
delete [] tableLen;
write_back();
return 0;
}
void eval(void)
{ int tmp ;
int tmp___0 ;
int tmp___1 ;
int tmp___2 ;
int tmp___3 ;
{
{
while (1) {
while_4_continue: /* CIL Label */ ;
if ((int )wl_st == 0) {
} else {
if ((int )c1_st == 0) {
} else {
if ((int )c2_st == 0) {
} else {
if ((int )wb_st == 0) {
} else {
if ((int )r_st == 0) {
} else {
goto while_4_break;
}
}
}
}
}
if ((int )wl_st == 0) {
{
tmp = __VERIFIER_nondet_int();
}
if (tmp) {
{
wl_st = 1;
write_loop();
}
} else {
}
} else {
}
if ((int )c1_st == 0) {
{
tmp___0 = __VERIFIER_nondet_int();
}
if (tmp___0) {
{
c1_st = 1;
compute1();
}
} else {
}
} else {
}
if ((int )c2_st == 0) {
{
tmp___1 = __VERIFIER_nondet_int();
}
if (tmp___1) {
{
c2_st = 1;
compute2();
}
} else {
}
} else {
}
if ((int )wb_st == 0) {
{
tmp___2 = __VERIFIER_nondet_int();
}
if (tmp___2) {
{
wb_st = 1;
write_back();
}
} else {
}
} else {
}
if ((int )r_st == 0) {
{
tmp___3 = __VERIFIER_nondet_int();
}
if (tmp___3) {
{
r_st = 1;
read();
}
} else {
}
} else {
}
}
while_4_break: /* CIL Label */ ;
}
return;
}
}
Node* RecordManager::get_column_data(char* tableName, int columnId, vector<CursePair>& curseTable)
{
string filename(tableName);
filename+=".db";
load_file(filename);
if (m_header.entryCount == 0)
{
write_back();
return nullptr;
}
Node *root = m_columndata.newEmptyNode();
root->operation = m_header.columnType[columnId];
Node *ptr = root;
Node *ptrNext = nullptr;
// from flag back to column
int initial_offset = 0;
for (int i = m_header.columnCount - 1; i >= columnId; --i)
{
initial_offset += m_header.columnLength[i];
}
// all
int blockNo = 0;
unsigned char* block = m_bufInstance->getblock(m_currentPage, blockNo, BUFFER_FLAG_NONDIRTY);
unsigned char* blockPtr = block+m_header.headerLength+m_header.valLength;
for (int i = m_header.entryCount; i>0;)
{
if (*(int*)blockPtr < 0)
{
--i;
ptrNext = m_columndata.newEmptyNode();
if (root->operation == VAL_CHAR)
{
ptrNext->strval = new char[m_header.columnLength[columnId]+1];
strncpy(ptrNext->strval, (char*)(blockPtr - initial_offset), m_header.columnLength[columnId]);
(ptrNext->strval)[m_header.columnLength[columnId]]=0;
}
else if (root->operation == VAL_FLOAT)
{
ptrNext->numval = *(float*)(blockPtr - initial_offset);
}
else
{
ptrNext->numval = *(int*)(blockPtr - initial_offset);
}
ptr->leftSon = ptrNext;
ptr = ptrNext;
curseTable.push_back(std::make_pair(blockNo, blockPtr-block-m_header.valLength));
}
blockPtr += (m_header.valLength+sizeof(int));
if ((blockPtr+sizeof(int)) > (block+BLOCK_SIZE))
{
block = m_bufInstance->getblock(m_currentPage, ++blockNo, BUFFER_FLAG_NONDIRTY);
blockPtr = block+m_header.valLength;
}
}
root->leftSon->operation = m_header.columnType[columnId];
write_back();
return root->leftSon;
}
