void
heap_sort(
void* base,
size_t size,
size_t count,
int (*compare)(const void*, const void*))
{
sort_t s;
char* tail;
s.head = (char*)base;
s.size = size;
s.count = count;
s.compare = compare;
/* Make heap. */
{
int i;
for (i = count - 1; i >= 0; --i) {
insert_heap(&s, i);
}
}
for (tail = s.head + size * (count - 1); s.head < tail; tail -= s.size)
{
swap(s.head, tail, s.size);
s.count -= 1;
insert_heap(&s, 0);
}
}
//handles token k+1 when the first k tokens are all the same
void handle_second_distinct(Estimator_type* est, c_a* token)
{
double r;
Sample_type* cur;
est->two_distinct_tokens = 1;
for(int i = 0; i < est->c; i++)
{
cur = est->samplers[i];
r = prng_float(est->prng);
if(r < cur->t0)
{
cur->val_c_s1 = cur->val_c_s0;
cur->c_s1 = cur->c_s0;
cur->t1 = cur->t0;
cur->val_c_s0 = 1;
cur->c_s0=token;
cur->t0=r;
}
else
{
cur->val_c_s1 = 1;
cur->c_s1 = token;
cur->t1 = r;
}
reset_wait_times(cur, est);
//must reset wait times before inserting into prim heap or
//incrementing prim samplers (because increment_prim_samplers() handles
//insertion/restoring heap property in c_s0's heap and est's bheapneeds
//and hence needs the wait times to be set properly as precondition
insert_heap(est->prim_heap, cur);
increment_prim_samplers(cur->c_s0, est->bheap, cur);
increment_backup_samplers(cur->c_s1);
}
}
//called by Estimator_Update to handle first token in stream
//slightly more efficient than just using handle_nondistinct
static void naive_handle_first(Naive_Estimator_type* est, c_a* first)
{
for(int i = 0; i < est->c; i++)
{
est->samplers[i]->c_s0=first;
est->samplers[i]->val_c_s0=1;
est->samplers[i]->t0=prng_float(est->prng);
naive_increment_prim_samplers(first);
naive_reset_wait_times(est->samplers[i], est);
insert_heap(est->prim_heap, est->samplers[i]);
}
}
int manageContextSwitching( RunningState* run_state, Heap* ready_queue,
DeviceSet* device_set, ConfigData* configurations,
ActivityLog* activity_log )
{
// case: we have a process that was running
if( run_state->process_is_running )
{
// move the process to its next task and place the process in
// the back of the ready queue
increment_iterator( &(run_state->currently_running_process.job_list) );
insert_heap( ready_queue, run_state->currently_running_process,
configurations->cpu_scheduler );
run_state->process_is_running = false;
}
// get one from the queue if possible
if( !is_Heap_empty( ready_queue ) )
{
// pop the item out of the queue
run_state->currently_running_process =
remove_PCB_from_Heap( ready_queue );
run_state->process_is_running = true;
}
// case: there are no items to remove from the queue
// leave the run state empty, with no process running
// perform context switches until we get a processor destined
// for the CPU or we are out of processeses to get
while( ( get_listTask( &(run_state->currently_running_process.job_list) ).task_number != PROCESS ) &&
!is_Heap_empty( ready_queue ) )
{
// send the process to the I/O queue it is destined for
sendToIoQueue( &(run_state->currently_running_process), device_set,
activity_log );
// get one from the queue if possible
if( !is_Heap_empty( ready_queue ) )
{
// pop the item out of the queue
run_state->currently_running_process =
remove_PCB_from_Heap( ready_queue );
}
// case: there are no items to remove from the queue
// leave the run state empty, with no process running
}
// now we will either have a process ready for the CPU or all
// processes will be doing their I/O operations
// (or the simulator run will be just about over)
}
int main (int argc, char *argv[])
{
puzzle best_soln;
int best_cost;
int i;
puzzle s, t, u;
int lbsf;
initialize_heap();
get_puzzle(&s);
startTime = clock()/1000;
print_puzzle(s);
insert_heap(s);
best_cost = 999;
lbsf = 0;
while(heap_size > 0) {
u = delete_heap();
if (u.lower_bound > lbsf) {
lbsf = u.lower_bound;
}
if (u.lower_bound >= best_cost) break;
if (solved(u)) {
if (u.lower_bound < best_cost) {
s = u;
best_cost = u.lower_bound;
}
} else {
for (i = 0; i < possible_moves[u.hole]; i++) {
t = make_move (u, i);
insert_heap (t);
}
}
}
print_solution (s);
printf("Finished in %i milliseconds.\n", clock()/1000 - startTime);
}
void sort_heap(int arr[], int len) {
// construct heap
int i;
for (i = 0; i < len; ++i) {
printf("heap: \n");
insert_heap(heap, i, arr[i]);
array_display(heap, 1+i+1);
}
// sort
for (i = 0; i < len; ++i) {
printf("sort: \n");
arr[i] = heap_pop(len-i);
array_display(arr, i+1);
}
}
void decrease_key( int item )
{
int i = find_key( item );
if ( i == -1 )
{
insert_heap( item );
}
while ( i > 1 && value( heap[i / 2] ) > value( item ) )
{
heap[i] = heap[i / 2];
i = i / 2;
}
heap[i] = item;
}
int get_min_kvalues(int *max_heap)
{
int n = 0;
int data = 0;
int k = 0;
int count = 0;
FILE *fin = fopen("5.in", "r");
if (fin == NULL) {
return -1;
}
fscanf(fin, "%d %d", &n, &k);
while(fscanf(fin, "%d", &data) != EOF) {
if (count < k) {
if (insert_heap(max_heap, data, count) != 0) {
return -1;
}
++count;
}
if (count == k && data < max_heap[0]) {
max_heap[0] = data;
keep_max_heap(max_heap, 0, k);
}
}
if (ferror(fin) != 0) {
return -1;
}
fclose(fin);
for (count = 0; count < k; ++count) {
fprintf(stdout, "%d ", max_heap[count]);
}
fprintf(stdout, "\n");
return 0;
}
static void _run() {
init_heap();
insert_heap(1);
_printAll();
insert_heap(2);
_printAll();
insert_heap(3);
_printAll();
insert_heap(4);
_printAll();
insert_heap(5);
_printAll();
insert_heap(6);
_printAll();
insert_heap(7);
_printAll();
}
int sendToIoQueue( PCB* process, DeviceSet* device_set,
ActivityLog* activity_log )
{
// variables
int io_task_type =
(get_listTask( &(process->job_list) ) ).task_number;
Device* requested_device = NULL;
// assert a precondition that the process is not a processing one
assert( io_task_type != PROCESS );
// pick which device the process needs to use
requested_device = &(device_set->device_number[io_task_type]);
// add the device to the appropriate I/O queue where it will be handled
// in I/O management
insert_heap( &(requested_device->waiting_queue),
*process, FIFO_HEAP );
}
int main()
{
int a[MAX_SIZE];
int n=0,ch,item;
while(1)
{
printf("\n1. Insert\n2. Delete\n3. Display\n4. Exit\n Enter your choice : ");
scanf("%d",&ch);
switch(ch)
{
case 1:printf("Enter the item to insert : ");
scanf("%d",&item);
n=insert_heap(item,a,n);break;
case 2:n=delete_heap(a,n);break;
case 3:display(a,n);break;
case 4:return 0;
default:printf("Invalid Choice");
}
}
return 0;
}
//process a new token read from the stream
void Naive_Estimator_Update(Naive_Estimator_type * est, int token)
{
est->count++;
Freq_Update(est->freq, token);
//end of Misra-Gries part of algorithm
//increment count of token, sets processing to 1
c_a* counter = naive_increment_count(est->hashtable, token);
if(est->count == 1)
{
naive_handle_first(est, counter);
return;
}
Sample_type* min;
while(((Sample_type*) peek_min(est->prim_heap))->prim <= est->count)
{
min=delete_min(est->prim_heap);
if(min->prim < est->count)
{
fprintf(stderr, "a sampler's prim decreased. fatal error\n");
fprintf(stderr, "min->c_s0_key: %d, min->prim %d, est->count %d\n",
min->c_s0->key, min->prim, est->count);
exit(1);
}
naive_decrement_prim_samplers(est->hashtable, min->c_s0);
naive_increment_prim_samplers(counter);
//have min take a new sample
min->c_s0 = counter;
min->val_c_s0 = counter->count;
min->t0 *= prng_float(est->prng);
naive_reset_wait_times(min, est);
//reinsert min into primary heap
insert_heap(est->prim_heap, min);
}
naive_done_processing(est->hashtable, counter);
}
int manageIoDevice( Device* device, Heap* ready_queue,
ActivityLog* activity_log )
{
// variables
char action_message[STD_STR_LEN];
PCB temp;
// case: an I/O completion interrupt has been raised
if( device->data.interrupt_flag )
{
// time this action
stopwatch( 's', IO_TIMER );
// kill the I/O simulating thread
pthread_join( device->data.thread_id, NULL );
// release the device from the process, load it into the main
// scheduler
device->data.interrupt_flag = false;
device->data.in_use = false;
insert_heap( ready_queue, *(device->working_process), FIFO_HEAP );
device->working_process = NULL;
// log this action
sprintf( action_message, "%s action completed for process %d - "
"process placed back in main scheduler",
device->name, device->working_process->pid );
logEvent( activity_log, SYSTEM, action_message,
stopwatch( 'x', IO_TIMER ) );
}
// case: an I/O processed is running and needs to be managed
else if( device->data.in_use )
{
// log the maintenance of the process (simulate with a short wait)
stopwatch( 's', IO_TIMER );
usleep( IO_MANAGEMENT_TIME );
sprintf( action_message,
"I/O maintnenance: %s still in use by process %d",
device->name, device->working_process->pid );
logEvent( activity_log, SYSTEM, action_message,
stopwatch( 'x', IO_TIMER ) );
}
// case: an I/O process is wating to run and the I/O device is free
// (it is possible that the device was previously freed previously)
if( !(device->data.in_use) && !is_Heap_empty( &(device->waiting_queue ) ) )
{
// start the I/O process on this device
stopwatch( 's', IO_TIMER );
temp = remove_PCB_from_Heap( &(device->waiting_queue) );
device->working_process = &temp;
// startup the independent I/O action (simulated of course)
pthread_attr_init( &(device->data.attribute) );
pthread_create( &(device->data.thread_id), &(device->data.attribute),
conductIoProcess, (void*) &(device->data) );
// log the action
sprintf( action_message, "Starting process %d on %s",
device->working_process->pid, device->name );
logEvent( activity_log, SYSTEM, action_message,
stopwatch( 'x', IO_TIMER ) );
}
}
void dijkstra( int lift, int start )
{
int i, l, v, pre;
bool intree[MAXLIFTS][MAXFLOORS];
memset( intree, false, sizeof( intree ) );
distance[lift][start] = 0;
heap[1] = lift * 100 + start;
heap_size = 1;
l = lift, v = start;
while ( 1 )
{
if ( heap_size == 0 )
{
break;
}
extract_min( l, v );
intree[l][v] = true;
for ( i = 0; i < MAXFLOORS; ++i )
{
if ( a[l][v][i] != -1 )
{
if ( a[l][v][i] + distance[l][v] < distance[l][i] )
{
pre = distance[l][i];
distance[l][i] = a[l][v][i] + distance[l][v];
if ( pre == INF )
{
insert_heap( l * 100 + i );
}
else
{
decrease_key( l * 100 + i );
}
}
}
}
if ( v != 0 )
{
for ( i = 0; i < lifts; ++i )
{
if ( r[i][v] == true && distance[l][v] + 60 < distance[i][v] )
{
pre = distance[i][v];
distance[i][v] = distance[l][v] + 60;
if ( pre == INF )
{
insert_heap( i * 100 + v );
}
else
{
decrease_key( i * 100 + v );
}
}
}
}
}
}
//process a new token read from the stream
void Estimator_Update(Estimator_type * est, int token)
{
int old_cs0pos, old_backupminuswait, wait;
est->count++;
Freq_Update(est->freq, token);
//end of Misra-Gries part of algorithm
//In the case that a sampler is scheduled to take a new backup and
//primary sample at the same time, we should use more random bits to
//break the tie. But for now, for simplicity, we'll break all such
//ties by having the sampler take a new *primary* sample
//increment count of token, sets processing to 1
c_a* counter = increment_count(est->hashtable, token);
//check for special cases
if(est->count == 1)
{
est->first = counter;
handle_first(est, counter);
return;
}
if(counter->count == est->count)
{
handle_nondistinct(est, counter);
return;
}
if(est->two_distinct_tokens == 0)
{
handle_second_distinct(est, counter);
//indicate that we are done for the time being with two
//distinct tokens in the stream so they can be removed from
//the hashtable if no samplers are sampling them
done_processing(est->hashtable, counter);
done_processing(est->hashtable, est->first);
return;
}
//only restore heap prop if samplers have been put in bheap
restore_bheap_property(est->bheap, counter->backup_pos);
Sample_type* min;
c_a* old_c_s1 = NULL;
while(((Sample_type*) peek_min(est->prim_heap))->prim <= est->count)
{
min=delete_min(est->prim_heap);
if(min->prim < est->count)
{
fprintf(stderr, "a sampler's prim decreased. fatal error\n");
fprintf(stderr, "min->c_s0_key: %d, min->prim %d, est->count %d\n",
min->c_s0->key, min->prim, est->count);
exit(1);
}
//have min take a new primary sample
if(min->c_s0 == counter)
{
min->val_c_s0 = counter->count;
min->t0 *= prng_float(est->prng);
//resample primary and backup wait times using new values of t0 and t1
reset_wait_times(min, est);
restore_c_a_heap_property(min->c_s0->sample_heap, min->c_s0_pos);
restore_bheap_property(est->bheap, min->c_s0->backup_pos);
}
else
{
old_c_s1 = min->c_s1;
min->c_s1 = min->c_s0;
min->val_c_s1 = min->val_c_s0;
min->t1 = min->t0;
min->c_s0 = counter;
min->val_c_s0 = counter->count;
min->t0 *= prng_float(est->prng);
//resample primary and backup wait times using new values of t0 and t1
old_cs0pos = min->c_s0_pos;
old_backupminuswait = min->backup_minus_delay;
reset_wait_times(min, est);
//increment backup samplers for c_s1 first, b/c if we decremented
//prim samplers first and min was the only primary sampler of c_s1 and
//c_s1 had no backup samplers, then c_s1 would be removed from the hashtable
//which we don't want. Note increment_backup_samplers does *not* change
//min->c_s0_pos, so the subsequent call to decrement_prim_samplers will work fine
//when it tries to remove min from c_s1's heap of samplers
increment_backup_samplers(min->c_s1);
decrement_backup_samplers(est->hashtable, old_c_s1);
decrement_prim_samplers(est->hashtable, min->c_s1, est->bheap, min);
increment_prim_samplers(counter, est->bheap, min);
}
//reinsert min into primary heap
insert_heap(est->prim_heap, min);
}
c_a* min2 = peek_min_bheap(est->bheap);
min = peek_min_c_a_heap(min2->sample_heap);
double r1;
while(min->backup_minus_delay + min2->count <= est->count)
{
if(min->backup_minus_delay + min2->count < est->count)
{ //error check
fprintf(stderr, "error: sampler's backup wait time decreased\n");
fprintf(stderr, "bminusd %d, min2->count %d est->count %d\n",
min->backup_minus_delay, min2->count, est->count);
exit(1);
}
decrement_backup_samplers(est->hashtable, min->c_s1);
increment_backup_samplers(counter);
min->t1 -= prng_float(est->prng) * (min->t1-min->t0);
min->c_s1 = counter;
min->val_c_s1 = counter->count;
//recalculate just min's backup wait time
r1 = prng_float(est->prng);
if(r1 == 0) min->backup_minus_delay = est->count + 1 - min->c_s0->count;
else
{
if(min->t1-min->t0 == 0)
{ //t0 == t1 should cause longest possible wait time
min->backup_minus_delay = MAX_WAIT-min->c_s0->count;
}
else
{
wait = ceil(log(r1)/log(1.0-(min->t1-min->t0)));
if(wait < 0 || wait > MAX_WAIT) //check for overflow
min->backup_minus_delay = MAX_WAIT-min->c_s0->count;
else
min->backup_minus_delay = wait + est->count - min->c_s0->count;
}
}
//fprintf(stderr, "%d ", min->backup_minus_delay);
//put min in proper position in its primary sample's heap
restore_c_a_heap_property(min->c_s0->sample_heap, min->c_s0_pos);
//put min's primary sample in proper position in backup heap
restore_bheap_property(est->bheap, min->c_s0->backup_pos);
min2 = peek_min_bheap(est->bheap);
min = peek_min_c_a_heap(min2->sample_heap);
}
done_processing(est->hashtable, counter);
}
