示例#1
0
文件: formula.cpp 项目: xpsair/NVSim
double CalculateDrainCap(
		double width, int type,
		double heightTransistorRegion, Technology tech) {
	double drainCap = 0;
	if (type == NMOS)
		CalculateGateCapacitance(INV, 1, width, 0, heightTransistorRegion, tech, NULL, &drainCap);
	else
		CalculateGateCapacitance(INV, 1, 0, width, heightTransistorRegion, tech, NULL, &drainCap);
	return drainCap;
}
示例#2
0
void Comparator::CalculateRC() {
	if (!initialized) {
		cout << "[Comparator] Error: Require initialization first!" << endl;
	} else {
		for (int i = 0; i < COMPARATOR_INV_CHAIN_LEN; i++) {
			CalculateGateCapacitance(INV, 1, widthNMOSInv[i], widthPMOSInv[i], tech->featureSize * MAX_TRANSISTOR_HEIGHT, *tech, &(capInput[i]), &(capOutput[i]));
		}
		double capComp, capTemp;
		CalculateGateCapacitance(NAND, 2, widthNMOSComp, 0, tech->featureSize*40, *tech, &capTemp, &capComp);
		capBottom = capOutput[COMPARATOR_INV_CHAIN_LEN-1] + numTagBits * capComp;
		capTop = numTagBits * capComp + CalculateDrainCap(widthPMOSComp, PMOS, tech->featureSize * MAX_TRANSISTOR_HEIGHT, *tech) + capLoad;
		resBottom = CalculateOnResistance(widthNMOSInv[COMPARATOR_INV_CHAIN_LEN-1], NMOS, inputParameter->temperature, *tech);
		resTop = 2 * CalculateOnResistance(widthNMOSComp, NMOS, inputParameter->temperature, *tech);
	}
}
示例#3
0
void TSV::_CalculateLatencyAndPower(double _rampInput, double &_dynamicEnergy, double &_latency)
{
    //Buffer chain delay and Dynamic Power
    double delay = 0.0;
    double rd, tf, this_delay, c_load, c_intrinsic; 
    double capInput, capOutput;
    double rampInput, rampOutput;
    double beta = 0.5; /* Carried over from CACTI3DD. */

    if (num_gates > 0) {
        rd = CalculateOnResistance(w_TSV_n[0], NMOS, inputParameter->temperature, *tech);
        CalculateGateCapacitance(INV, 1, w_TSV_n[1], w_TSV_p[1], tech->featureSize * MAX_TRANSISTOR_HEIGHT, *tech, &capInput, &capOutput);

        c_load = capInput + capOutput;
        c_intrinsic = CalculateDrainCap(w_TSV_p[0], PMOS, tech->featureSize * MAX_TRANSISTOR_HEIGHT, *tech) 
                     + CalculateDrainCap(w_TSV_n[0], NMOS, tech->featureSize * MAX_TRANSISTOR_HEIGHT, *tech);
        tf = rd * (c_intrinsic + c_load);

        // NVSIM3D - _rampInput should be subarray's senseAmpMuxLev2 rampOutput
        rampInput = _rampInput;
        this_delay = horowitz(tf, beta, rampInput, &rampOutput);
        delay += this_delay;

        double Vdd = tech->vdd;
        _dynamicEnergy = (c_load + c_intrinsic) * Vdd * Vdd;

        int i;
        for (i = 1; i < num_gates - 1; ++i)
        {
            rd = CalculateOnResistance(w_TSV_n[i], NMOS, inputParameter->temperature, *tech);
            CalculateGateCapacitance(INV, 1, w_TSV_n[i+1], w_TSV_p[i+1], tech->featureSize * MAX_TRANSISTOR_HEIGHT, *tech, &capInput, &capOutput);

            c_load = capInput + capOutput;
            c_intrinsic = CalculateDrainCap(w_TSV_p[i], PMOS, tech->featureSize * MAX_TRANSISTOR_HEIGHT, *tech) 
                       + CalculateDrainCap(w_TSV_n[i], NMOS, tech->featureSize * MAX_TRANSISTOR_HEIGHT, *tech);

            tf = rd * (c_intrinsic + c_load);
            rampInput = rampOutput;
            this_delay = horowitz(tf, beta, rampInput, &rampOutput);
            delay += this_delay;

            _dynamicEnergy += (c_load + c_intrinsic) * Vdd * Vdd;
        }

        // add delay of final inverter that drives the TSV
        i = num_gates - 1;
        c_load = C_load_TSV;

        rd = CalculateOnResistance(w_TSV_n[i], NMOS, inputParameter->temperature, *tech);
        c_intrinsic = CalculateDrainCap(w_TSV_p[i], PMOS, tech->featureSize * MAX_TRANSISTOR_HEIGHT, *tech) 
                     + CalculateDrainCap(w_TSV_n[i], NMOS, tech->featureSize * MAX_TRANSISTOR_HEIGHT, *tech);

        double R_TSV_out = res;
        tf = rd * (c_intrinsic + c_load) + R_TSV_out * c_load / 2;

        rampInput = rampOutput;
        this_delay = horowitz(tf, beta, rampInput, &rampOutput);
        delay  += this_delay;

        _dynamicEnergy += (c_load + c_intrinsic) * Vdd * Vdd;

        _latency = delay;
    } else {
        rampInput = _rampInput;
        c_load = cap;
        double R_TSV_out = res;
        tf = R_TSV_out * c_load / 2;
        double Vdd = tech->vdd;

        this_delay = horowitz(tf, beta, rampInput, &rampOutput);
        delay  += this_delay;

        _dynamicEnergy += (c_load) * Vdd * Vdd;

        _latency = delay;
    }
}