void shm_close_map(uint64_t id){
hold_lock(shm_lock, false);
if(mappings->has_key(id)){
shm_mapping *mapping = (*mappings)[id];
bt_pid_t pid = proc_current_pid;
proc_switch(mapping->pid);
current_pagedir->remove_region(mapping->addr);
void *addr = mapping->addr;
for(uint32_t i = (uint32_t)addr; i < (uint32_t)addr + (mapping->pages * MM2_Page_Size); i += MM2_Page_Size){
current_pagedir->map_page_at((void*)i, MM2_PageFlags::Present | MM2_PageFlags::Writable | MM2_PageFlags::Usermode);
}
delete mapping;
mappings->erase(id);
proc_switch(pid);
}
}
// <@$M_{t1}$@> module
void acq () {
uint myt = FAI_ticket();
while(get_now()!=myt){};
hold_lock();
}
int SRLockClient::start_operation (SRClientContext &ctx) {
struct timespec firstRequestTime, lastRequestTime, beforeAcquisition, afterAcquisition, beforeRelease, afterRelease;
char temp_char;
struct LockRequest req_cpy;
double sumExclusiveAcqTime= 0.0, sumSharedAcqTime= 0.0, sumExclusiveRelTime= 0.0, sumSharedRelime= 0.0;
double acquisitionTime, releaseTime;
int exclusiveCount= 0, sharedCount= 0;
clock_gettime(CLOCK_REALTIME, &firstRequestTime); // Fire the timer
ctx.op_num = 0;
while (ctx.op_num < OPERATIONS_CNT) {
ctx.op_num = ctx.op_num + 1;
DEBUG_COUT (std::endl << "[Info] Submitting lock request #" << ctx.op_num);
// ************************************************************************
// Client request a lock on the selected item and waits for a response.
select_item(ctx.lock_request);
req_cpy.request_item = ctx.lock_request.request_item; // to keep track of the initial request type, because ctx.lock_request is going to change
req_cpy.request_type = ctx.lock_request.request_type; // to keep track of the initial request type, because ctx.lock_request is going to change
clock_gettime(CLOCK_REALTIME, &beforeAcquisition); // Fire the timer
acquire_lock (ctx, ctx.lock_request, ctx.lock_response);
clock_gettime(CLOCK_REALTIME, &afterAcquisition); // Fire the timer
acquisitionTime = ( afterAcquisition.tv_sec - beforeAcquisition.tv_sec ) * 1E6 + ( afterAcquisition.tv_nsec - beforeAcquisition.tv_nsec )/1E3;
// hold lock for a specified time period (in a specific way).
hold_lock();
// ************************************************************************
// Clients release the acquired lock.
ctx.lock_request.request_type = LockRequest::RELEASE;
clock_gettime(CLOCK_REALTIME, &beforeRelease); // Fire the timer
release_lock (ctx, ctx.lock_request, ctx.lock_response);
clock_gettime(CLOCK_REALTIME, &afterRelease); // Fire the timer
releaseTime = ( afterRelease.tv_sec - beforeRelease.tv_sec ) * 1E6 + ( afterRelease.tv_nsec - beforeRelease.tv_nsec )/1E3;
if(req_cpy.request_type == LockRequest::EXCLUSIVE){
sumExclusiveAcqTime += acquisitionTime;
sumExclusiveRelTime += releaseTime;
exclusiveCount++;
}
else if(req_cpy.request_type == LockRequest::SHARED){
sumSharedAcqTime += acquisitionTime;
sumSharedRelime += releaseTime;
sharedCount++;
}
}
clock_gettime(CLOCK_REALTIME, &lastRequestTime); // Fire the timer
double micro_elapsed_time = ( lastRequestTime.tv_sec - firstRequestTime.tv_sec ) * 1E6 + ( lastRequestTime.tv_nsec - firstRequestTime.tv_nsec )/1E3;
double lock_per_sec = (double)(OPERATIONS_CNT / (double)(micro_elapsed_time / 1000000));
// std::cout << std::endl << "[Stat] Locks (acquire & release) per sec: " << lock_per_sec << std::endl;
// std::cout << "[STAT] Avg time per Exclusive acquisition (us) " << sumExclusiveAcqTime / exclusiveCount << std::endl;
// std::cout << "[STAT] Avg time per Exclusive release (us) " << sumExclusiveRelTime / exclusiveCount << std::endl;
// std::cout << "[STAT] Avg time per Shared acquisition (us) " << sumSharedAcqTime / sharedCount << std::endl;
// std::cout << "[STAT] Avg time per Shared release (us) " << sumSharedRelime / sharedCount << std::endl;
std::cout << "[Summary] " << lock_per_sec << ", " << sumExclusiveAcqTime / exclusiveCount << ", " << sumExclusiveRelTime / exclusiveCount << ", " << sumSharedAcqTime / sharedCount << ", " << sumSharedRelime / sharedCount << std::endl;
return 0;
}
