text.cc

linux下基于c++的处理器仿真平台。具有处理器流水线

    Result samples;

    Counter min;
    Counter max;
    Counter bucket_size;
    int size;
    bool fancy;

    void operator()(ostream &stream) const;
};

void
DistPrint::operator()(ostream &stream) const
{
    if (fancy) {
	ScalarPrint print;
	string base = name + (compat ? "_" : "::");

	print.precision = precision;
	print.flags = flags;
	print.compat = compat;
	print.descriptions = descriptions;
	print.desc = desc;
	print.pdf = NAN;
	print.cdf = NAN;

	print.name = base + "mean";
	print.value = samples ? sum / samples : NAN;
	print(stream);

	print.name = base + "stdev";
	print.value = samples ? sqrt((samples * squares - sum * sum) /
				     (samples * (samples - 1.0))) : NAN;
	print(stream);

	print.name = "**Ignore: " + base + "TOT";
	print.value = samples;
	print(stream);
	return;
    }

    assert(size == vec.size());

    Result total = 0.0;

    total += underflow;
    for (int i = 0; i < size; ++i)
	total += vec[i];
    total += overflow;

    string base = name + (compat ? "." : "::");

    ScalarPrint print;
    print.desc = compat ? "" : desc;
    print.flags = flags;
    print.compat = compat;
    print.descriptions = descriptions;
    print.precision = precision;
    print.pdf = NAN;
    print.cdf = NAN;

    if (compat) {
	ccprintf(stream, "%-42s", base + "start_dist");
	if (descriptions && !desc.empty())
	    ccprintf(stream, "                     # %s", desc);
	stream << endl;
    }

    print.name = base + "samples";
    print.value = samples;
    print(stream);

    print.name = base + "min_value";
    print.value = min_val;
    print(stream);

    if (!compat || underflow > 0.0) {
	print.name = base + "underflows";
	print.value = underflow;
	if (!compat && total) {
	    print.pdf = underflow / total;
	    print.cdf += print.pdf;
	}
	print(stream);
    }


    if (!compat) {
	for (int i = 0; i < size; ++i) {
	    stringstream namestr;
	    namestr << name;

	    Counter low = i * bucket_size + min;
	    Counter high = ::min(low + bucket_size, max);
	    namestr << low;
	    if (low < high)
		namestr << "-" << high;

	    print.name = namestr.str();
	    print.value = vec[i];
	    if (total) {
		print.pdf = vec[i] / total;
		print.cdf += print.pdf;
	    }
	    print(stream);
	}

    } else {
	Counter _min;
	Result _pdf;
	Result _cdf = 0.0;

	print.flags = flags | __substat;

	for (int i = 0; i < size; ++i) {
	    if (flags & nozero && vec[i] == 0.0 ||
		flags & nonan && isnan(vec[i]))
		continue;

	    _min = i * bucket_size + min;
	    _pdf = vec[i] / total * 100.0;
	    _cdf += _pdf;


	    print.name = ValueToString(_min, 0, compat);
	    print.value = vec[i];
	    print.pdf = (flags & pdf) ? _pdf : NAN;
	    print.cdf = (flags & cdf) ? _cdf : NAN;
	    print(stream);
	}

	print.flags = flags;
    }

    if (!compat || overflow > 0.0) {
	print.name = base + "overflows";
	print.value = overflow;
	if (!compat && total) {
	    print.pdf = overflow / total;
	    print.cdf += print.pdf;
	} else {
	    print.pdf = NAN;
	    print.cdf = NAN;
	}
	print(stream);
    }

    print.pdf = NAN;
    print.cdf = NAN;

    if (!compat) {
	print.name = base + "total";
	print.value = total;
	print(stream);
    }

    print.name = base + "max_value";
    print.value = max_val;
    print(stream);

    if (!compat && samples != 0) {
	print.name = base + "mean";
	print.value = sum / samples;
	print(stream);

	print.name = base + "stdev";
	print.value = sqrt((samples * squares - sum * sum) /
			   (samples * (samples - 1.0)));
	print(stream);
    }

    if (compat)
	ccprintf(stream, "%send_dist\n\n", base);
}

void
Text::visit(const ScalarData &data)
{
    if (noOutput(data))
	return;

    ScalarPrint print;
    print.value = data.result();
    print.name = data.name;
    print.desc = data.desc;
    print.flags = data.flags;
    print.compat = compat;
    print.descriptions = descriptions;
    print.precision = data.precision;
    print.pdf = NAN;
    print.cdf = NAN;

    print(*stream);
}

void
Text::visit(const VectorData &data)
{
    if (noOutput(data))
	return;

    int size = data.size();
    VectorPrint print;

    print.name = data.name;
    print.desc = data.desc;
    print.flags = data.flags;
    print.compat = compat;
    print.descriptions = descriptions;
    print.precision = data.precision;
    print.vec = data.result();
    print.total = data.total();

    if (!data.subnames.empty()) {
	for (int i = 0; i < size; ++i) {
	    if (!data.subnames[i].empty()) {
		print.subnames = data.subnames;
		print.subnames.resize(size);
		for (int i = 0; i < size; ++i) {
		    if (!data.subnames[i].empty() &&
			!data.subdescs[i].empty()) {
			print.subdescs = data.subdescs;
			print.subdescs.resize(size);
			break;
		    }
		}
		break;
	    }
	}
    }

    print(*stream);
}

void
Text::visit(const Vector2dData &data)
{
    if (noOutput(data))
	return;

    bool havesub = false;
    VectorPrint print;

    print.subnames = data.y_subnames;
    print.flags = data.flags;
    print.compat = compat;
    print.descriptions = descriptions;
    print.precision = data.precision;

    if (!data.subnames.empty()) {
	for (int i = 0; i < data.x; ++i)
	    if (!data.subnames[i].empty())
		havesub = true;
    }

    VResult tot_vec(data.y);
    Result super_total = 0.0;
    for (int i = 0; i < data.x; ++i) {
	if (havesub && (i >= data.subnames.size() || data.subnames[i].empty()))
	    continue;

	int iy = i * data.y;
	VResult yvec(data.y);

	Result total = 0.0;
	for (int j = 0; j < data.y; ++j) {
	    yvec[j] = data.cvec[iy + j];
	    tot_vec[j] += yvec[j];
	    total += yvec[j];
	    super_total += yvec[j];
	}

	print.name = data.name + "_" + (havesub ? data.subnames[i] : to_string(i));
	print.desc = data.desc;
	print.vec = yvec;
	print.total = total;
	print(*stream);
    }

    if ((data.flags & ::Stats::total) && (data.x > 1)) {
	print.name = data.name;
	print.desc = data.desc;
	print.vec = tot_vec;
	print.total = super_total;
	print(*stream);
    }
}

void
Text::visit(const DistData &data)
{
    if (noOutput(data))
	return;

    DistPrint print;

    print.name = data.name;
    print.desc = data.desc;
    print.flags = data.flags;
    print.compat = compat;
    print.descriptions = descriptions;
    print.precision = data.precision;

    print.min_val = data.data.min_val;
    print.max_val = data.data.max_val;
    print.underflow = data.data.underflow;
    print.overflow = data.data.overflow;
    print.vec.resize(data.data.cvec.size());
    for (int i = 0; i < print.vec.size(); ++i)
	print.vec[i] = (Result)data.data.cvec[i];
    print.sum = data.data.sum;
    print.squares = data.data.squares;
    print.samples = data.data.samples;

    print.min = data.data.min;
    print.max = data.data.max;
    print.bucket_size = data.data.bucket_size;
    print.size = data.data.size;
    print.fancy = data.data.fancy;

    print(*stream);
}

void
Text::visit(const VectorDistData &data)
{
    if (noOutput(data))
	return;

    for (int i = 0; i < data.size(); ++i) {
	DistPrint print;

	print.name = data.name +
	    (data.subnames[i].empty() ? ("_" + to_string(i)) : data.subnames[i]);
	print.desc = data.subdescs[i].empty() ? data.desc : data.subdescs[i];
	print.flags = data.flags;
	print.compat = compat;
	print.descriptions = descriptions;
	print.precision = data.precision;

	print.min_val = data.data[i].min_val;
	print.max_val = data.data[i].max_val;
	print.underflow = data.data[i].underflow;
	print.overflow = data.data[i].overflow;
	print.vec.resize(data.data[i].cvec.size());
	for (int j = 0; j < print.vec.size(); ++j)
	    print.vec[j] = (Result)data.data[i].cvec[j];
	print.sum = data.data[i].sum;
	print.squares = data.data[i].squares;
	print.samples = data.data[i].samples;

	print.min = data.data[i].min;
	print.max = data.data[i].max;
	print.bucket_size = data.data[i].bucket_size;
	print.size = data.data[i].size;
	print.fancy = data.data[i].fancy;

	print(*stream);
    }
}

void
Text::visit(const FormulaData &data)
{
    visit((const VectorData &)data);
}

/* namespace Stats */ }