Скачиваний:
9
Добавлен:
02.05.2014
Размер:
8.88 Кб
Скачать
#include <vcl.h>
#pragma hdrstop
#include "main.h"
#pragma package(smart_init)
#pragma link "RzEdit"
#pragma link "RzSpnEdt"
#pragma link "RzButton"
#pragma link "RzRadChk"
#pragma resource "*.dfm"

TMainForm *MainForm;

__fastcall TMainForm::TMainForm(TComponent* Owner) : TForm(Owner) {
}

struct signal {
	int canal_time;
    int canal_planned;
    int queue_time;
    int vm_time;
    int vm_planned;
    signal() {
	    canal_time = 0;
	    canal_planned = 0;
	    queue_time = 0;
	    vm_time = 0;
	    vm_planned = 0;
    }
};

void __fastcall TMainForm::StartButtonClick(TObject *Sender) {
	this->Enabled = false;

	randomize();

	int source_period = (int)this->SourcePeriod->Value;
	int source_deviation = (int)this->SourceDeviation->Value;
    int source_planned = 0;

	int canal_period = (int)this->CanalPeriod->Value;
	int canal_deviation = (int)this->CanalDeviation->Value;

	int vm_period = (int)this->VmPeriod->Value;
	int vm_deviation = (int)this->VmDeviation->Value;

    int accel_period = (int)this->AcceleraionTime->Value;
    int accel_queue = (int)this->AcceleraionCount->Value;

    int time_value = 0;

    int signals_max = (int)this->SignalsMax->Value;
    int signals_generated = 0;
    int signals_canal = 0;
    int signals_queue = 0;
    int signals_processed = 0;
    int signals_lost = 0;

    signal** canal = new signal*[500];
    for (int i=0; i<500; i++) canal[i] = 0;

	int queue_length = (int)this->QueueLength->Value;

    bool queue1_closed = false;
    signal** queue1 = new signal*[queue_length];
    for (int i=0; i<queue_length; i++) queue1[i] = 0;
    int queue1_tail = 0;

    bool queue2_closed = false;
    signal** queue2 = new signal*[queue_length];
    for (int i=0; i<queue_length; i++) queue2[i] = 0;
    int queue2_tail = 0;

    bool queue3_closed = false;
    signal** queue3 = new signal*[queue_length];
    for (int i=0; i<queue_length; i++) queue3[i] = 0;
    int queue3_tail = 0;

    bool vm1_closed = false;
    signal* vm1_signal = 0;
    bool vm2_closed = false;
    signal* vm2_signal = 0;
    bool vm3_closed = false;
    signal* vm3_signal = 0;

	int canal_time = 0;
	int queue1_time = 0;
	int queue2_time = 0;
	int queue3_time = 0;
    int vm1_time = 0;
    int vm2_time = 0;
    int vm3_time = 0;

    while (signals_generated < signals_max) {
    	// acceleration
        if (this->AcceleraionCheckbox->State==cbChecked) {
	    	if (queue1_tail+queue2_tail+queue3_tail >= accel_queue) {
    	    	vm_period = accel_period;
        	}
        }
        // generating signals
    	if (time_value==source_planned) {
        	signal* new_signal = new signal();
            new_signal->canal_planned = time_value + canal_period + (random(canal_deviation)-canal_deviation/2);
		    for (int i=0; i<500; i++) {
            	if (canal[i]==0) {
                	canal[i] = new_signal;
                    break;
                }
            }
            signals_generated++;
            source_planned = time_value + source_period + (random(source_deviation)-source_deviation/2);
        }
        // processing canal
	    for (int i=0; i<500; i++) {
	        signal* current_signal = canal[i];
            if (!current_signal) continue;
            if (current_signal->canal_planned > time_value) {
	            current_signal->canal_time++;
            } else {
            	if (queue1_closed && queue2_closed && queue3_closed) {
                	signals_lost++;
                } else {
	            	if ((queue1_tail <= queue2_tail)&&(queue1_tail <= queue3_tail)) {
                    	queue1[queue1_tail] = current_signal;
                        queue1_tail++;
                        if (queue1_tail >= queue_length) queue1_closed = true;
    	            } else if ((queue2_tail <= queue1_tail)&&(queue2_tail <= queue3_tail)) {
                    	queue2[queue2_tail] = current_signal;
                        queue2_tail++;
                        if (queue2_tail >= queue_length) queue2_closed = true;
        	        } else {
                    	queue3[queue3_tail] = current_signal;
                        queue3_tail++;
                        if (queue3_tail >= queue_length) queue3_closed = true;
            	    }
                }
				signals_canal++;
            	canal[i] = 0;
            }
        }
        // processing queue 1
        for (int i=0; i<queue1_tail; i++) {
			queue1[i]->queue_time++;
        }
        if (!vm1_closed) {
        	vm1_signal = queue1[0];
	        if (vm1_signal) {
	            vm1_signal->vm_planned = time_value + vm_period + (random(vm_deviation)-vm_deviation/2);
                vm1_closed = true;
		        for (int i=1; i<queue1_tail; i++) {
					queue1[i-1] = queue1[i];
        		}
            	if (queue1_tail > 0) {
                	queue1_tail--;
	                queue1[queue1_tail] = 0;
                }
    	    }
        }
        // processing queue 2
        for (int i=0; i<queue2_tail; i++) {
			queue2[i]->queue_time++;
        }
        if (!vm2_closed) {
        	vm2_signal = queue2[0];
	        if (vm2_signal) {
	            vm2_signal->vm_planned = time_value + vm_period + (random(vm_deviation)-vm_deviation/2);
                vm2_closed = true;
	        	for (int i=1; i<queue2_tail; i++) {
					queue2[i-1] = queue2[i];
    	    	}
	            if (queue2_tail > 0) {
                	queue2_tail--;
	                queue2[queue2_tail] = 0;
                }
    	    }
        }
        // processing queue 3
        for (int i=0; i<queue3_tail; i++) {
			queue3[i]->queue_time++;
        }
        if (!vm3_closed) {
        	vm3_signal = queue3[0];
	        if (vm3_signal) {
	            vm3_signal->vm_planned = time_value + vm_period + (random(vm_deviation)-vm_deviation/2);
                vm3_closed = true;
		        for (int i=1; i<queue3_tail; i++) {
					queue3[i-1] = queue3[i];
        		}
            	if (queue3_tail > 0) {
                	queue3_tail--;
	                queue3[queue3_tail] = 0;
                }
     	    }
        }

        // processing vm 1
        if (vm1_signal) {
        	if (vm1_signal->vm_planned > time_value) {
	            vm1_signal->vm_time++;
            } else {
            	canal_time += vm1_signal->canal_time;
            	queue1_time += vm1_signal->queue_time;
            	vm1_time += vm1_signal->vm_time;
                vm1_signal = 0;
                vm1_closed = false;
                signals_processed++;
            }
        }
        // processing vm 2
        if (vm2_signal) {
        	if (vm2_signal->vm_planned > time_value) {
	            vm2_signal->vm_time++;
            } else {
            	canal_time += vm2_signal->canal_time;
            	queue2_time += vm2_signal->queue_time;
            	vm2_time += vm2_signal->vm_time;
                vm2_signal = 0;
                vm2_closed = false;
                signals_processed++;
            }
        }
        // processing vm 3
        if (vm3_signal) {
        	if (vm3_signal->vm_planned > time_value) {
	            vm3_signal->vm_time++;
            } else {
            	canal_time += vm3_signal->canal_time;
            	queue3_time += vm3_signal->queue_time;
            	vm3_time += vm3_signal->vm_time;
                vm3_signal = 0;
                vm3_closed = false;
                signals_processed++;
            }
        }
    	time_value++;
    }
    this->TotalTime->Caption = IntToStr(time_value-1)+" мсек";
    this->GeneratedSignals->Caption = IntToStr(signals_generated);
    this->LostSignals->Caption = IntToStr(signals_lost);
    this->OverflowProbability->Caption = FloatToStr((100.0*signals_lost)/(1.0*signals_generated))+"%";
    this->CanalDelay->Caption = AnsiString::FormatFloat("0.00", (1.0*canal_time)/(1.0*signals_processed))+" мсек";
    this->Queue1Delay->Caption = AnsiString::FormatFloat("0.00", (1.0*queue1_time)/(1.0*signals_processed))+" мсек";
    this->Queue2Delay->Caption = AnsiString::FormatFloat("0.00", (1.0*queue2_time)/(1.0*signals_processed))+" мсек";
    this->Queue3Delay->Caption = AnsiString::FormatFloat("0.00", (1.0*queue3_time)/(1.0*signals_processed))+" мсек";
    this->ProcessingSignals->Caption = IntToStr(signals_generated-signals_processed-signals_lost);
    this->ProcessedSignals->Caption = IntToStr(signals_processed);

	this->Enabled = true;
}
void __fastcall TMainForm::ExitButtonClick(TObject *Sender) {
	this->Close();
}
void __fastcall TMainForm::AcceleraionCheckboxClick(TObject *Sender) {
	this->AcceleraionTime->Enabled = this->AcceleraionCheckbox->State==cbChecked;
    this->AcceleraionCount->Enabled = this->AcceleraionCheckbox->State==cbChecked;
}

Соседние файлы в папке Курсовой проект [19] [программа]
  • #
    02.05.20144.94 Кб9course.bpr
  • #
    02.05.2014856 б9course.cpp
  • #
    02.05.20146.08 Кб9course.dsk
  • #
    02.05.2014595 б10course.exe.manifest
  • #
    02.05.20141.22 Кб9course.res
  • #
    02.05.20148.88 Кб9main.cpp
  • #
    02.05.2014136.64 Кб9main.dfm
  • #
    02.05.20142.31 Кб10main.h