void IonAcoustic_Initializer::init_particle(realkind& px, realkind& py, realkind& pz,
int& ix, int& iy, int& iz,
realkind& vx, realkind& vy, realkind& vz,
int ispecies, int iptcl,int nptcls,int ioffset)
{
// Set Position Values, ifloat = 0-2
raised_cos cdf(alpha,1.0/kt);
int nv1 = 4;
int iptcl_new = floor((((double)iptcl*pdata->nptcls_device[0]))/((double)nptcls));
iptcl_new = iptcl_new*pdata->node_info->nTasks_g + (pdata->node_info->rank_g);
iptcl_new = iptcl;
int idist = iptcl_new%(nptcls/nv1);
double temp_x;
px = distribution_intrp((idist)/(1.0/nv1*nptcls),0.0,pdata->Lx,cdf)+0.5*pdata->Lx;
// px = distribution_intrp(drandom(),0.0,pdata->Lx,cdf);
//vx = 0.0;
// vx = (2*(iptcl%2)-1)*sqrt(2.0*pdata->Te/(pdata->mspecies[0]*mass_e));
py = 0.5;
pz = 0.5;
ix = floor(px*pdata->didx);
iy = floor(py*pdata->didy);
iz = floor(pz*pdata->didz);
px = px*pdata->didx - ix;
py = py*pdata->didy - iy;
pz = pz*pdata->didz - iz;
ix = ((ix%pdata->nx)+pdata->nx)%pdata->nx;
// Set Velocity Values, ifloat = 3-5
// realkind ux = alpha*v_shift*sin((px+ix)*pdata->dxdi/kt) + v_shift;
realkind ux = alpha*sin((px+ix)*pdata->dxdi/kt)*9.7e-4*kt + v_shift;
if(ispecies == 0)
vx = box_muller(ux,sqrt(2.0*2.0e-4/(pdata->mspecies[ispecies]*mass_e)));
else
vx = box_muller(ux,sqrt(2.0*2.0e-4/(pdata->mspecies[ispecies]*mass_e)));
vy = 0;
vz = 0;
}
int main(int argc, char *argv[])
{
srand(time(NULL)); /* Set random seed */
printf("%f\n", box_muller(0, 2));
printf("%f\n", box_muller(0, 2));
printf("%f\n", box_muller(0, 2));
printf("%f\n", box_muller(0, 2));
printf("%f\n", box_muller(0, 2));
return 0;
}
int random_range(int lowest_number, int highest_number, DistributionType_t type /*= DISTRO_UNIFORM*/)
{
if(highest_number == lowest_number){
return lowest_number;
}
if(lowest_number > highest_number){
int nTmp = highest_number;
highest_number = lowest_number;
lowest_number = nTmp;
}
int range = highest_number - lowest_number;
if(type == DISTRO_UNIFORM){
int r = rand24b() % (range + 1);
return lowest_number + r;
}
else if(type == DISTRO_NORMAL){
float value = box_muller(0.5, 0.25);
if(value < 0){
value = 0;
}else if(value > 1){
value = 1;
}
return lowest_number + (int)((float)range * value);
}
else{
float r = 1.f - sqrt((1.f*rand24b())/RAND_MAX24);
return lowest_number + (int)((float)range * r);
}
}
void EnergyCons_Initializer::init_particle(realkind& px, realkind& py, realkind& pz,
int& ix, int& iy, int& iz,
realkind& vx, realkind& vy, realkind& vz,int ispecies, int iptcl)
{
// Set Position Values, ifloat = 0-2
px = ((2.0*iptcl)/((double)pdata->nptcls))*pdata->Lx+pdata->xmin;
vx = box_muller(0.0,sqrt(2.0*pdata->Te/(pdata->mspecies[0]*mass_e)));
py = 0.5;
pz = 0.5;
ix = floor(px*pdata->didx);
iy = floor(py*pdata->didy);
iz = floor(pz*pdata->didz);
px = px*pdata->didx - ix;
py = py*pdata->didy - iy;
pz = pz*pdata->didz - iz;
ix = ((ix%pdata->nx)+pdata->nx)%pdata->nx;
// Set Velocity Values, ifloat = 3-5
vy = 0;
vz = 0;
}
void AI::perturbShot(shot& theShot)
{
theShot.phi += box_muller(0, sigma_phi);
theShot.v += box_muller(0, sigma_v);
theShot.a += box_muller(0, sigma_a);
theShot.b += box_muller(0, sigma_b);
theShot.theta += box_muller(0, sigma_theta);
if(theShot.v > 4.5f) theShot.v = 4.5f;
if(theShot.v < 0.0f) theShot.v = 0.1f;
if(theShot.phi < 0.0f) theShot.phi += 360.0f;
if(theShot.phi > 360.0f) theShot.phi -= 360.0f;
if(theShot.a > ballRadiusInMM) theShot.a = ballRadiusInMM;
if(theShot.a < -ballRadiusInMM) theShot.a = -ballRadiusInMM;
if(theShot.b > ballRadiusInMM) theShot.b = ballRadiusInMM;
if(theShot.b < -ballRadiusInMM) theShot.b = -ballRadiusInMM;
}
void fill_gaussian_rng_stream(hls::stream<calc_t> &rns, unsigned size) {
double z0, z1;
for (unsigned i = 0; i < size; ++i) {
box_muller(z0, z1);
rns.write(z0);
if (++i < size)
rns.write(z1);
}
}
int findInPartition(float **image, double * mpsData, int imageLength, int imageWidth, double ulEasting, double ulNorthing,
int run_range3, float range3_min, float range3_max,
int run_range5, float range5_min, float range5_max,
int run_range7, float range7_min, float range7_max,
SHPHandle hshp, DBFHandle hdbf, int add_noise)
{
puts("findInPartition");
/*
float range3_max, range5_max;
range3_max = range5_min;
range5_max = range7_min;
*/
float **gridded = allocf2d(imageLength, imageWidth);
if(!gridded){
return 0;
}
copy(image, gridded, imageLength, imageWidth);
smooth(image, gridded, imageLength, imageWidth);
int i, j;
if (add_noise) {
for(i = 1; i < imageLength-1; i++)
for(j = 1; j < imageWidth-1; j++)
gridded[i][j] += box_muller(0,1)*0.001;
}
for(j = 3/*1*/; j < imageWidth-3/*1*/; j++)//each col
{
for(i = 3/*1*/; i < imageLength-3/*1*/; i++) //each row
{
float height = gridded[i][j];
if(run_range3 && height >= range3_min && height < range3_max)
{
checkPixelPart(gridded, image, i, j, 3, 9, mpsData, ulEasting, ulNorthing, hshp, hdbf);
}
else if(run_range5 && height >= range5_min && height < range5_max)
{
checkPixelPart(gridded, image, i, j, 5, 25, mpsData, ulEasting, ulNorthing, hshp, hdbf);
}
else if(run_range7 && height >= range7_min && height < range7_max)
{
checkPixelPart(gridded, image, i, j, 7, 49, mpsData, ulEasting, ulNorthing, hshp, hdbf);
}
}
}
freef2d(image, imageLength);
freef2d(gridded, imageLength);
return 1;
}
double * generate_random_vector(int n,int seed)
{
int i;
double * vect=malloc(n * sizeof(double));
srand(seed);
for (i=0; i<n; i++)
{
vect[i] = box_muller(0,0.1);
}
return vect;
}
int main() {
init_genrand(0);
uint32_t ain[100];
hls::stream<uint32_t> din;
hls::stream<float> dout;
for (int i = 0; i < 100; ++i) {
uint32_t rn = genrand_int32();;
ain[i] = rn;
din.write(rn);
}
float aout[100];
for (int i = 0; i < 100/2; ++i) {
float u1 = to_float(ain[2 * i]);
float u2 = to_float(ain[2 * i + 1]);
box_muller(u1, u2);
aout[2 * i] = u1;
aout[2 * i + 1] = u2;
}
gauss_transform(din, dout);
if (dout.size() != 100) {
std::cout << "wrong size" << std::endl;
return -1;
}
for (int i = 0; i < 100; ++i) {
float hw = dout.read();
float sw = aout[i];
std::cout << i << ": \t" << hw << " \t(hw) - (sw) " << sw <<
std::endl;
if (!(std::isfinite(hw) and std::isfinite(sw) and
std::abs(hw - sw) < 1E-4)) {
std::cout << "ERROR: " << i << ": \t" << hw << " \t(hw|sw) "
<< sw << std::endl;
return -1;
}
}
std::cout << "passed." << std::endl;
return 0;
}
int32_t random_range(int32_t lowestNumber, int32_t highestNumber, DistributionType_t type /*= DISTRO_UNIFORM*/)
{
if(highestNumber == lowestNumber)
return lowestNumber;
if(lowestNumber > highestNumber)
std::swap(lowestNumber, highestNumber);
switch(type)
{
case DISTRO_UNIFORM:
return (lowestNumber + ((int32_t)rand24b() % (highestNumber - lowestNumber + 1)));
case DISTRO_NORMAL:
return (lowestNumber + int32_t(float(highestNumber - lowestNumber) * (float)std::min((float)1, std::max((float)0, box_muller(0.5, 0.25)))));
default:
break;
}
const float randMax = 16777216;
return (lowestNumber + int32_t(float(highestNumber - lowestNumber) * float(1.f - sqrt((1.f * rand24b()) / randMax))));
}
/**
* Add error checking.
*
* orig - buffered tiff elevation model
* minNorthing - ulNorthing
* minEasting - ulEasting
*/
int findTreeTops(float **orig, double * mpsData, int imageLength, int imageWidth, double ulEasting, double ulNorthing,
int run_range3, float range3_min, float range3_max,
int run_range5, float range5_min, float range5_max,
int run_range7, float range7_min, float range7_max,
int run_range9, float range9_min, float range9_max,
int run_range11, float range11_min, float range11_max,
SHPHandle hshp, DBFHandle hdbf, int smooth_type, int add_noise)
{
puts("findTreeTops");
int i, j, length, width;
float **gridded;
// dimensions of gridded
length = imageLength + 4;
width = imageWidth + 4;
gridded = smoothAndPad(orig, imageLength, imageWidth, smooth_type);
if(!gridded)
return 0;
if (add_noise) {
for(i = 1; i < length - 1; i++)
for(j = 1; j < width - 1 ; j++)
gridded[i][j] += box_muller(0,1)*0.001;
}
//determine if necessary
extrapolateEdges(gridded, length, width);
puts("Checking pixels.");
for(j = 2; j < width-2; j++)//each col
{
for(i = 2; i < length-2; i++) //each row
{
float height = gridded[i][j];
// 3 = 1 + 2
if(i >= 3 && j >= 3 && i < length-3 && j < width-3 && run_range3 && height >= range3_min && height < range3_max)
{
checkPixel(gridded, orig, i, j, 3, 9, mpsData, ulEasting, ulNorthing, hshp, hdbf);
}
// 4 = 2 + 2 = half_window+buffer
else if(i >= 4 && j >= 4 && i < length-4 && j < width-4 && run_range5 && height >= range5_min && height < range5_max)
{
checkPixel(gridded, orig, i, j, 5, 25, mpsData, ulEasting, ulNorthing, hshp, hdbf);
}
else if(i >= 5 && j >= 5 && i < length-5 && j < width-5 && run_range7 && height >= range7_min && height < range7_max)
{
checkPixel(gridded, orig, i, j, 7, 49, mpsData, ulEasting, ulNorthing, hshp, hdbf);
}
else if(i >= 6 && j >= 6 && i < length-6 && j < width-6 && run_range9 && height >= range9_min && height < range9_max)
{
checkPixel(gridded, orig, i, j, 9, 81, mpsData, ulEasting, ulNorthing, hshp, hdbf);
}
else if(i >= 7 && j >= 7 && i < length-7 && j < width-7 && run_range11 && height >= range11_min && height < range11_max)
{
checkPixel(gridded, orig, i, j, 11, 121, mpsData, ulEasting, ulNorthing, hshp, hdbf);
}
}
}
freef2d(gridded, length);
freef2d(orig, imageLength);
return 1;
}
void TwoStream_Initializer::init_particle(realkind& px, realkind& py, realkind& pz,
int& ix, int& iy, int& iz,
realkind& vx, realkind& vy, realkind& vz,int ispecies, int iptcl)
{
// Set Position Values, ifloat = 0-2
raised_cos cdf(alpha,1.0/kt);
int iptcl_new = floor((((double)iptcl*pdata->nptcls_cpu))/((double)pdata->my_nptcls));
iptcl_new = iptcl_new*pdata->num_nodes + (pdata->mynode);
int idist = iptcl_new%(pdata->nptcls_cpu*pdata->num_nodes/2);
int ivel = iptcl_new/(pdata->nptcls_cpu*pdata->num_nodes/2);
double temp_x;
if(ispecies == 0)
temp_x = distribution_intrp((idist+0.5)/(0.5*pdata->nptcls_cpu*pdata->num_nodes),0.0,pdata->Lx,cdf);
else
temp_x = (iptcl/100.0)/(0.01*pdata->my_nptcls) * pdata->Lx + pdata->xmin;
// int iptcl_new = iptcl;
//
// int idist = iptcl_new%(pdata->nptcls/2);
// int ivel = iptcl_new/(pdata->nptcls/2);
//
// double temp_x;
//
// if(ispecies == 0)
// temp_x = distribution_intrp((idist+0.5)/(0.5*pdata->nptcls),0.0,pdata->Lx,cdf);
// else
// px = iptcl/(1.0*pdata->nptcls) * pdata->Lx + pdata->xmin;
//px = box_muller(0.5,0.1);
///px = ((2.0*iptcl)/((double)pdata->nptcls))*pdata->Lx+pdata->xmin;
//vx = 1.0*(2*(ivel%2)-1)*(exp(-(ivel/2)/100.0));
//vx = sqrt(2.0*pdata->Te/(pdata->mspecies[0]*mass_e))
// *sqrt(-2.0*log((ivel2+0.5)/((realkind)nv2)))*cos(2.0*3.14159265359*(ivel1)/((realkind)nv1));
//temp_x = drandom();
//printf("random number = %f\n",px);
// Set Velocity Values, ifloat = 3-5
if(ispecies == 0)
vx = 0.1*(1-(2*(ivel)));
else
vx = box_muller(0.0,0.01/sqrt(pdata->mspecies[ispecies]));
py = 0.0;
pz = 0.0;
ix = floor(temp_x*pdata->didx);
iy = floor(py*pdata->didy);
iz = floor(pz*pdata->didz);
px = temp_x*pdata->didx - ix;
py = py*pdata->didy - iy;
pz = pz*pdata->didz - iz;
//px = drandom();
ix = ((ix%pdata->nx)+pdata->nx)%pdata->nx;
}
void Island_Initializer::init_particle(realkind& px, realkind& py, realkind& pz,
int& ix, int& iy, int& iz,
realkind& vx, realkind& vy, realkind& vz,int ispecies, int iptcl,
int nptcls,int ioffset)
{
// Set Position Values, ifloat = 0-2
// raised_cos cdf(alpha,1.0/kt);
double temp_x;
temp_x = distribution_intrp(drandom(),
0.0,pdata->nx*pdata->ny,*cdf);
int itemp = floor(temp_x);
iy = itemp/pdata->nx ;
ix = itemp - iy*pdata->nx -1;
px = drandom();
py = drandom();
// int iptcl_new = iptcl;
//
// int idist = iptcl_new%(pdata->nptcls/2);
// int ivel = iptcl_new/(pdata->nptcls/2);
//
// double temp_x;
//
// if(ispecies == 0)
// temp_x = distribution_intrp((idist+0.5)/(0.5*pdata->nptcls),0.0,pdata->Lx,cdf);
// else
// px = iptcl/(1.0*pdata->nptcls) * pdata->Lx + pdata->xmin;
//px = box_muller(0.5,0.1);
///px = ((2.0*iptcl)/((double)pdata->nptcls))*pdata->Lx+pdata->xmin;
//vx = 1.0*(2*(ivel%2)-1)*(exp(-(ivel/2)/100.0));
//vx = sqrt(2.0*pdata->Te/(pdata->mspecies[0]*mass_e))
// *sqrt(-2.0*log((ivel2+0.5)/((realkind)nv2)))*cos(2.0*3.14159265359*(ivel1)/((realkind)nv1));
//temp_x = drandom();
//printf("random number = %f\n",px);
// Set Velocity Values, ifloat = 3-5
vx = box_muller(0.0,1.0/sqrt(pdata->mspecies[ispecies]));
vy = box_muller(0.0,1.0/sqrt(pdata->mspecies[ispecies]));
vz = B0/(4*pi_const*lambda)*pdata->qspecies[ispecies];
pz = 0.0;
iz = 0;
pz = 0;
//px = drandom();
ix = ((ix%pdata->nx)+pdata->nx)%pdata->nx;
iy = ((iy%pdata->ny)+pdata->ny)%pdata->ny;
// printf("ix,iy,iz[%i] = %i %i %i\n",iptcl,ix,iy,iz);
}
int main(int argc, char *argv[])
{
FILE *fp;
long jobCount=0, count=0;
long subTime, runTime, numProcessor, code, queueNum;
Event *event=NULL;
srand(1);
long i,j,nq,startQueue;
double sum=0, ratioSum=0, completionSum=0;
long maxWaitTime, minWaitTime, maxWaitTimeRunTime, maxWaitTimeJobIndex;
long minWaitTimeRunTime, minWaitTimeJobIndex, maxCompletionTime, minCompletionTime;
double maxWaitRatio, minWaitRatio;
long maxWaitRatioRunTime, maxWaitRatioJobIndex, minWaitRatioRunTime;
long minWaitRatioJobIndex,maxCompletionTimeJobIndex,minCompletionTimeJobIndex;
double waitTimeVarianceSum, waitRatioVarianceSum, completionTimeVarianceSum;
double averageWaitTime, averageWaitRatio, averageCompletionTime;
long load;
long lowVSP=0;
long hiVSP=0;
long temp;
double RealCPUtime=0;
long totalCPUnumber=0;
double CPUTime=0;
long forbug=0;
double Rtime=0;
long kneeP;
char** order=NULL;
order=(char**)malloc(sizeof(char*));
double kmin=0;
double kmax=0;
int orderType=-1;
int debug=0;
long start_time=0;
long end_time=0;
start_time = clock();
maxWaitTime = 0;
minWaitTime = 1000000;
maxWaitRatio = 0;
minWaitRatio = 1000000;
if (argc != 13)
{
printf("need input file name, processor number, start queue number, and queue number, efficiency, distribution, load!\n");
exit(-1);
}
fp = fopen(argv[1],"r");
np = atoi(argv[2]);
startQueue = atoi(argv[3]);
nq = atoi(argv[4]);
efficiency = atof(argv[5]);
distribution = atoi(argv[6]);
load = atoi(argv[7]);
method = atoi(argv[8]);
dynamic = atoi(argv[9]);
//printf("%s\n",argv[10]);
//getchar();
*order = argv[10];
kmin = atof(argv[11]);
kmax = atof(argv[12]);
if(debug==-1){
printf("kmin =%f\nkmax=%f\n",kmin,kmax);
//getchar();
printf("order =%s\n\n",*order);
}
if(strcmp(*order,"EDF")==0)
orderType = EDF;
else if(strcmp(*order,"LLF")==0)
orderType = LLF;
else if(strcmp(*order,"LPF")==0)
orderType = LPF;
else if(strcmp(*order,"SJF")==0)
orderType = SJF;
else{ printf("error order!!!\n");getchar();}
//getchar();
if(debug==-1){
printf("M %d D %d\n",method,dynamic);
printf("load=%d\n",load);}
switch (distribution)
{
case 0:
//according to workload trace
if(debug==-1)
printf("distribution according to workload trace\n");
break;
case 1:
//uniform distribution;
printf("uniform distribution\n");
break;
case 2:
//normal distribution
printf("normal distribution\n");
break;
case 3:
// knee
puts("Low variance optimal cluster size");
break;
case 4:
// knee
puts("High variance optimal cluster size");
break;
default:
printf("error in specifying distribution\n");
getchar();
exit(-1);
break;
}
if(debug==-1){
printf("method = %d\ndynamic type=%d\n",method,dynamic);
printf("np is %ld\n",np);
printf("efficiency is %f\n",efficiency);
}
while (fscanf(fp,"%*ld %ld %*ld %ld %ld %*ld %*ld %*ld %*ld %*ld %ld %*ld %*ld %*ld %ld %*ld %*ld %*ld",&subTime, &runTime,&numProcessor,&code,&queueNum) != EOF)
{
//if((runTime*numProcessor<10000))continue;
//if((runTime*numProcessor<20000)||(runTime*numProcessor>150000))continue;
//initialize deadline !!!
//************************************************
if (code == 0 || code == 1)
{
jobs[jobCount].subTime = subTime;
jobs[jobCount].runTime = (long) (runTime)*load;
//printf("No.%ld's runtime=%ld\n",jobCount,jobs[jobCount].runTime);
//system("pause");
// set the maximum runtime!!
if (maxRunTime < jobs[jobCount].runTime)
maxRunTime = jobs[jobCount].runTime;
switch (distribution)
{
case 0:
jobs[jobCount].produce(0.0, 1.0, 0.1, 1.0, 32.0, 1.0);
jobs[jobCount].np =numProcessor;
//according to workload trace
// printf("np: %ld\n",numProcessor);
//getchar();
break;
case 1:
//uniform distribution;
numProcessor = 1 + (int)((double)np*rand()/(RAND_MAX+1.0));
if ((jobs[jobCount].runTime/10) != 0)
jobs[jobCount].runTime /= 10;
//printf("np: %ld\n",numProcessor);
//getchar();
break;
case 2:
//normal distribution
numProcessor = (long) (box_muller(0,np/6)+(np/2));
if (numProcessor > np)
{
numProcessor = np;
}
if (numProcessor < 1)
{
numProcessor = 1;
}
if ((jobs[jobCount].runTime/10) != 0)
jobs[jobCount].runTime /= 10;
//printf("np: %ld\n",numProcessor);
//getchar();
break;
case 3:
jobs[jobCount].produce(0.0, 1.0, 0.1, 1.0, 32.0, 1.0);
lowVSP = jobs[jobCount].lowVSpeedup(numProcessor);
kneeP = jobs[jobCount].randomizedSpeedup();
temp = (lowVSP/jobs[jobCount].lowVSpeedup(kneeP));
jobs[jobCount].runTime = temp* jobs[jobCount].runTime;
jobs[jobCount].np = kneeP;
break;
case 4:
jobs[jobCount].produce(1.0, 20.0, 1.0, 1.0, 32.0, 1.0);
hiVSP= jobs[jobCount].highVSpeedup(numProcessor);
kneeP =jobs[jobCount].randomizedSpeedup();
temp = (hiVSP/jobs[jobCount].highVSpeedup(kneeP));
jobs[jobCount].runTime = temp* jobs[jobCount].runTime;
jobs[jobCount].np = kneeP;
/* (jobs[jobCount].lowVSpeedup(0.0, 1.0, 0.1, 1.0, 32.0, 1.0,numProcessor)*jobs[jobCount].runTime)/lowVSP;*/
break;
default:
printf("error in specifying distribution\n");
getchar();
exit(-1);
break;
}
jobs[jobCount].queueNum = queueNum;
event = new Event(submit, jobs[jobCount].subTime, jobCount);
eventQueue.enQueue(event);
jobCount++;
}
}
// initialize the deadline for all jobs
long tnp;
for(int k=0;k<jobCount;k++)
{
tnp = jobs[k].np;
jobs[k].deadlineRatio=fRand(kmin,kmax);
jobs[k].runTime1 = (jobs[k].runTime*jobs[k].np)/efficiency;
jobs[k].initDeadline();
jobs[k].laxity = jobs[k].deadline - jobs[k].subTime - (jobs[k].runTime1/numProcessor);
jobs[k].profit = jobs[k].np*jobs[k].runTime;
jobs[k].loss = 100000-jobs[k].profit;
//printf("The No. %d job's deadline ratio is %lf\n deadline is %ld\n",k,jobs[k].deadlineRatio,jobs[k].deadline);
//printf("The No. %d job's runTime1 is %ld\n\n",k,jobs[k].runTime1);
//if(k==150)system("pause");
}
fclose(fp);
if(debug==-1){
printf("Job count is %ld\n",jobCount);
printf("eventQueue length: %ld\n",eventQueue.length());
printf("***start loading data...***\n");
}
debug=0;
//printf("Begin processing event queue\n");
event = NULL;
event = eventQueue.deQueue();
while(event != NULL)
{
if (currentTime > event->time)
{
printf("error in time order\n");
printf("currentTime, event->time, event->type, event->jobIndex: %ld %ld %ld %ld\n",currentTime, event->time, event->type, event->jobIndex);
exit(-1);
}
currentTime = event->time;
//printf("type= %d\n",event->type);
switch (event->type)
{
case submit:
//printf("sub b\n");
if(orderType==EDF)
waitQueue.enQueueEDF(event->jobIndex);
else if(orderType==LLF)
waitQueue.enQueueLLF(event->jobIndex);
else if(orderType==LPF)
waitQueue.enQueueLPF(event->jobIndex);
else if(orderType==SJF)
waitQueue.enQueueSJF(event->jobIndex);
else{ printf("error order!!!\n");getchar();}
//printf("b delete\nevent=0x%x\n",event);
if(debug==1)
printf("JJJJJJJJJ job submitted: %ld\ttime = %ld np = %d\n\n",event->jobIndex,currentTime,np);
//printf("event = oX%x",event);
//getchar();
//delete event;
//event=NULL;
//printf("a d\n");
//printf("ST b schedule\n");
if(debug==1){
for(int i=0;i<waitQueue.count;i++)
printf("q [%d] = %ld \tdeadline = %ld\n",i,waitQueue.queue[i],jobs[waitQueue.queue[i]].deadline);
printf("before submit schedule np= %d\n",np);
getchar();
}
schedule();
if(debug==1){
printf("AAAAAA After schedule...of submitting\n\n");
for(int i=0;i<waitQueue.count;i++)
printf("q [%d] = %ld \tdeadline = %ld\n",i,waitQueue.queue[i],jobs[waitQueue.queue[i]].deadline);
getchar();}
//printf("ST a schedule\n");
break;
case end:{
np += jobs[event->jobIndex].np;
delete event;
//event=NULL;
//printf("End b schedule\n");
if(debug==1){
for(int i=0;i<waitQueue.count;i++)
printf("q [%d] = %ld \tdeadline = %ld\n",i,waitQueue.queue[i],jobs[waitQueue.queue[i]].deadline);
printf("before end schedule np= %d\n",np);
getchar();}
schedule();
if(debug==1){
printf("AAAAAA After schedule...of end time = %ld np = %d\n\n",currentTime,np);
printf("J18 meet = %d\n",jobs[18].meetDeadline);
for(int i=0;i<waitQueue.count;i++)
printf("q [%d] = %ld \tdeadline = %ld\n",i,waitQueue.queue[i],jobs[waitQueue.queue[i]].deadline);
getchar();}
//printf("End a schedule\n");
break;}
default:
//printf("error default!!\n");
break;
}
event = eventQueue.deQueue();
}
for (i=0; i<jobCount; i++)
{
sum += jobs[i].waitTime;
ratioSum += jobs[i].waitRatio;
completionSum += jobs[i].waitTime + jobs[i].runTime;
}
averageWaitTime = sum/jobCount;
averageWaitRatio = ratioSum/jobCount;
averageCompletionTime = completionSum/jobCount;
/*printf("Total job number: %ld\n",jobCount);
printf("Average waiting time and ratio: %f %f\n",sum/jobCount,ratioSum/jobCount);
printf("Average completion time: %f\n",completionSum/jobCount);*/
waitTimeVarianceSum = 0;
waitRatioVarianceSum = 0;
completionTimeVarianceSum = 0;
for (i=0; i<jobCount; i++)
{
waitTimeVarianceSum += (jobs[i].waitTime - averageWaitTime) * (jobs[i].waitTime - averageWaitTime);
waitRatioVarianceSum += (jobs[i].waitRatio - averageWaitRatio) * (jobs[i].waitRatio - averageWaitRatio);
completionTimeVarianceSum += (jobs[i].waitTime+jobs[i].runTime - averageCompletionTime) * (jobs[i].waitTime+jobs[i].runTime - averageCompletionTime);
}
/*printf("Variance and deviation for waiting time %f %f\n", waitTimeVarianceSum/jobCount, sqrt(waitTimeVarianceSum/jobCount));
printf("Variance and deviation for waiting ratio %f %f\n", waitRatioVarianceSum/jobCount, sqrt(waitRatioVarianceSum/jobCount));
printf("Variance and deviation for completion time %f %f\n", completionTimeVarianceSum/jobCount, sqrt(completionTimeVarianceSum/jobCount));*/
for (i=startQueue; i<startQueue + nq; i++)
{
sum = 0;
ratioSum = 0;
completionSum = 0;
count = 0;
for (j=0; j<jobCount; j++)
{
if (jobs[j].queueNum == i)
{
sum += jobs[j].waitTime;
ratioSum += jobs[j].waitRatio;
completionSum += jobs[j].waitTime + jobs[j].runTime;
count++;
}
}
//printf("Averaged waiting time and ratio for queue #%ld: %f %f\n", i, sum/count, ratioSum/count);
//printf("Averaged completion time for queue #%ld: %f n", i, completionSum/count);
averageWaitTime = sum/count;
averageWaitRatio = ratioSum/count;
averageCompletionTime = completionSum/count;
waitTimeVarianceSum = 0;
waitRatioVarianceSum = 0;
completionTimeVarianceSum = 0;
count =0;
for (j=0; j<jobCount; j++)
{
if (jobs[j].queueNum == i)
{
waitTimeVarianceSum += (jobs[j].waitTime - averageWaitTime) * (jobs[j].waitTime - averageWaitTime);
waitRatioVarianceSum += (jobs[j].waitRatio - averageWaitRatio) * (jobs[j].waitRatio - averageWaitRatio);
completionTimeVarianceSum += (jobs[j].waitTime+jobs[j].runTime - averageCompletionTime) * (jobs[j].waitTime+jobs[j].runTime - averageCompletionTime);
count++;
}
}
//printf("Variance and deviation for waiting time for queue#%ld %f %f\n", i, waitTimeVarianceSum/count, sqrt(waitTimeVarianceSum/count));
//printf("Variance and deviation for waiting ratio for queue#%ld %f %f\n", i, waitRatioVarianceSum/count, sqrt(waitRatioVarianceSum/count));
//printf("Variance and deviation for completion time for queue#%ld %f %f\n", i, completionTimeVarianceSum/count, sqrt(completionTimeVarianceSum/count));
}
double turnaroundTime = 0, averageturnaroundTime;
long count_meetDeadline=0;
long long totalMissMoney=0;
long long totalProfit=0;
for (i=0; i<jobCount; i++)
{
if(jobs[i].meetDeadline ==0)
{ totalMissMoney +=jobs[i].profit;
continue;}
totalProfit+=jobs[i].profit;
count_meetDeadline++;
totalCPUnumber += jobs[i].np;
CPUTime += (jobs[i].np*jobs[i].runTime );
RealCPUtime += (jobs[i].np*jobs[i].turnaroundTime);
Rtime += jobs[i].runTime;
turnaroundTime += jobs[i].turnaroundTime;
if (jobs[i].waitTime > maxWaitTime)
{
maxWaitTime = jobs[i].waitTime;
maxWaitTimeRunTime = jobs[i].runTime;
maxWaitTimeJobIndex = i;
}
if (jobs[i].waitTime < minWaitTime)
{
minWaitTime = jobs[i].waitTime;
minWaitTimeRunTime = jobs[i].runTime;
minWaitTimeJobIndex = i;
}
if (jobs[i].waitRatio > maxWaitRatio)
{
maxWaitRatio = jobs[i].waitRatio;
maxWaitRatioRunTime = jobs[i].runTime;
maxWaitRatioJobIndex = i;
}
if (jobs[i].waitRatio < minWaitRatio)
{
minWaitRatio = jobs[i].waitRatio;
minWaitRatioRunTime = jobs[i].runTime;
minWaitRatioJobIndex = i;
}
if ((jobs[i].waitTime+jobs[i].runTime) > maxCompletionTime)
{
maxCompletionTime = jobs[i].waitTime+jobs[i].runTime;
maxCompletionTimeJobIndex = i;
}
if ((jobs[i].waitTime+jobs[i].runTime) < minCompletionTime)
{
minCompletionTime = jobs[i].waitTime+jobs[i].runTime;
minCompletionTimeJobIndex = i;
}
}
//debug=-1;
averageturnaroundTime = turnaroundTime / count_meetDeadline;
if(debug==-1){
printf("jobCount:%ld\nmissCount:%ld\nmissrate:%lf%% \n",jobCount,jobCount-count_meetDeadline,(double)(jobCount-count_meetDeadline)/(double)jobCount*100);
end_time = clock();
printf("\n\ntime = %ld\n",end_time-start_time);
printf("maxWaitTime, runTime, jobIndex: %ld, %ld, %ld\n",maxWaitTime, maxWaitTimeRunTime, maxWaitTimeJobIndex);
printf("minWaitTime, runTime, jobIndex: %ld, %ld, %ld\n",minWaitTime, minWaitTimeRunTime, minWaitTimeJobIndex);
printf("maxCompletionTime, jobIndex: %ld, %ld\n",maxCompletionTime, maxCompletionTimeJobIndex);
printf("minCompletionTime, jobIndex: %ld, %ld\n",minCompletionTime, minCompletionTimeJobIndex);
printf("modling up count is %ld\n",moldUpCount);
printf("modling count is %ld\n",moldCount);
printf("maxWaitRatio, runTime, jobIndex: %f, %ld, %ld\n",maxWaitRatio, maxWaitRatioRunTime, maxWaitRatioJobIndex);
printf("minWaitRatio, runTime, jobIndex: %f, %ld, %ld\n",minWaitRatio, minWaitRatioRunTime, minWaitRatioJobIndex);
printf("Averaged queue length: %f\n",(double)queueLengthSum/(double)queueLengthCount);
printf("System completion time: %ld\n",currentTime);
printf("Average turnaround time: %lf\n", averageturnaroundTime);
//printf("AverageCPUwallclockTIME :%f\n", RealCPUtime/count_meetDeadline);
printf("AverageCPUnumber: %lf\n",(double)totalCPUnumber/(double)count_meetDeadline);
/*printf("AverageCPUTime add from all jobs is %f\n",CPUTime/count_meetDeadline);
printf("Average runTime :%f\n\n",Rtime/count_meetDeadline);
printf("Total Missed Money = %lld\n",totalMissMoney);*/
printf("Total Profit = \t %lld\n",totalProfit);
printf("np=%d\n",np);}
//printf("\n\ntime = %ld\n\n\n",end_time-start_time);
printf("m%d\t%s",dynamic+1,*order);
switch((int)efficiency){
case 1: printf("\tLinear");break;
default:printf("\tAMD");break;
}
printf("\t%.3f\t%ld\t%.3f\t%.3f\t--\t--\t%.3lf%%\t%.3lf\t%lld\t%.3lf\t%f\n",efficiency,load,kmin,kmax,(double)100*(jobCount-count_meetDeadline)/(double)jobCount,averageturnaroundTime,totalProfit,(double)totalCPUnumber/(double)count_meetDeadline,(double)queueLengthSum/(double)queueLengthCount);
if(debug==-1){
int cc=1;
getchar();
for (int i=0; i<300; i++)
{
//if(jobs[i].meetDeadline==0){
printf("%ld\t order: %ld\tsubTime: %ld\t ST: %ld\tRT: %ld\tFT: %ld\tDL: %ld\tProfit: %ld\t np:%d\tmeet= %d\n",i,jobs[i].exeNumber,jobs[i].subTime,jobs[i].startTime,(jobs[i].runTime1/jobs[i].np),jobs[i].startTime+(jobs[i].runTime1/jobs[i].np),jobs[i].deadline,jobs[i].profit,jobs[i].np,jobs[i].meetDeadline);
printf("DR=%lf\n",jobs[i].deadlineRatio);
//getchar();
//cc++;
//}//getchar();
}
printf("\n\n");
for(int e=1;e<=200;e++)
for(int a=0;a<500;a++)
{
if(e==jobs[a].exeNumber)
{
printf("%ld\t order: %ld\tsubTime: %ld\t ST: %ld\tRT: %ld\tFT: %ld\tDL: %ld\tProfit: %ld\t np:%d\tmeet= %d\n",a,jobs[a].exeNumber,jobs[a].subTime,jobs[a].startTime,(jobs[a].runTime1/jobs[a].np),jobs[a].startTime+(jobs[a].runTime1/jobs[a].np),jobs[a].deadline,jobs[a].profit,jobs[a].np,jobs[a].meetDeadline);
break;
}
}}
//getchar();
//printf("******************************************\n************************************\n\n\n");
//system("pause");
return 0;
}
