Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 2422d366 authored by Greg Kroah-Hartman's avatar Greg Kroah-Hartman
Browse files

greybus: Revert "gb_loopback: Fix throughput calculations" 



This reverts commit 9b9b046af237f5674c2f7ca991dc62332b2d4041

Bryan wants more feedback first.

Reported-by: default avatarBryan O'Donoghue <bryan.odonoghue@linaro.org>
Signed-off-by: default avatarGreg Kroah-Hartman <gregkh@google.com>
parent b07868bd

drivers/staging/greybus/loopback.c

+15 −42
Original line number Diff line number Diff line
@@ -81,7 +81,6 @@ struct gb_loopback { 
	atomic_t outstanding_operations;



	/* Per connection stats */

	struct timeval ts;

	struct gb_loopback_stats latency;

	struct gb_loopback_stats throughput;

	struct gb_loopback_stats requests_per_second;
@@ -521,6 +520,7 @@ static void gb_loopback_async_operation_callback(struct gb_operation *operation) 
		gb_loopback_push_latency_ts(gb, &op_async->ts, &te);

		gb->elapsed_nsecs = gb_loopback_calc_latency(&op_async->ts,

							     &te);

		gb_loopback_calculate_stats(gb);

	}



	if (op_async->pending) {
@@ -529,7 +529,6 @@ static void gb_loopback_async_operation_callback(struct gb_operation *operation) 
		del_timer_sync(&op_async->timer);

		gb_loopback_async_operation_put(op_async);

	}

	gb_loopback_calculate_stats(gb);

	mutex_unlock(&gb->mutex);



	dev_dbg(&gb->connection->bundle->dev, "complete operation %d\n",
@@ -847,7 +846,6 @@ static void gb_loopback_reset_stats(struct gb_loopback *gb) 
	/* Should be initialized at least once per transaction set */

	gb->apbridge_latency_ts = 0;

	gb->gpbridge_latency_ts = 0;

	memset(&gb->ts, 0, sizeof(struct timeval));

}



static void gb_loopback_update_stats(struct gb_loopback_stats *stats, u32 val)
@@ -862,15 +860,15 @@ static void gb_loopback_update_stats(struct gb_loopback_stats *stats, u32 val) 


static void gb_loopback_requests_update(struct gb_loopback *gb, u32 latency)

{

	u64 req = gb->requests_completed * USEC_PER_SEC;

	u32 req = USEC_PER_SEC;



	do_div(req, latency);

	gb_loopback_update_stats(&gb->requests_per_second, (u32)req);

	gb_loopback_update_stats(&gb->requests_per_second, req);

}



static void gb_loopback_throughput_update(struct gb_loopback *gb, u32 latency)

{

	u64 throughput;

	u32 throughput;

	u32 aggregate_size = sizeof(struct gb_operation_msg_hdr) * 2;



	switch (gb->type) {
@@ -889,13 +887,14 @@ static void gb_loopback_throughput_update(struct gb_loopback *gb, u32 latency) 
		return;

	}



	aggregate_size *= gb->requests_completed;

	throughput = aggregate_size * USEC_PER_SEC;

	/* Calculate bytes per second */

	throughput = USEC_PER_SEC;

	do_div(throughput, latency);

	gb_loopback_update_stats(&gb->throughput, (u32)throughput);

	throughput *= aggregate_size;

	gb_loopback_update_stats(&gb->throughput, throughput);

}



static void gb_loopback_calculate_latency_stats(struct gb_loopback *gb)

static void gb_loopback_calculate_stats(struct gb_loopback *gb)

{

	u32 lat;
@@ -908,6 +907,10 @@ static void gb_loopback_calculate_latency_stats(struct gb_loopback *gb) 
	/* Raw latency log on a per thread basis */

	kfifo_in(&gb->kfifo_lat, (unsigned char *)&lat, sizeof(lat));



	/* Log throughput and requests using latency as benchmark */

	gb_loopback_throughput_update(gb, lat);

	gb_loopback_requests_update(gb, lat);



	/* Log the firmware supplied latency values */

	gb_loopback_update_stats(&gb->apbridge_unipro_latency,

				 gb->apbridge_latency_ts);
@@ -915,27 +918,6 @@ static void gb_loopback_calculate_latency_stats(struct gb_loopback *gb) 
				 gb->gpbridge_latency_ts);

}



static void gb_loopback_calculate_stats(struct gb_loopback *gb)

{

	u64 nlat;

	u32 lat;

	struct timeval te;



	gb_loopback_calculate_latency_stats(gb);



	if (gb->iteration_count == gb->iteration_max) {

		do_gettimeofday(&te);

		nlat = gb_loopback_calc_latency(&gb->ts, &te);

		lat = gb_loopback_nsec_to_usec_latency(nlat);



		gb_loopback_throughput_update(gb, lat);

		gb_loopback_requests_update(gb, lat);



		memset(&gb->ts, 0, sizeof(struct timeval));

		gb->type = 0;

	}

}



static void gb_loopback_async_wait_to_send(struct gb_loopback *gb)

{

	if (!(gb->async && gb->outstanding_operations_max))
@@ -973,9 +955,7 @@ static int gb_loopback_fn(void *data) 


		/* Optionally terminate */

		if (send_count == gb->iteration_max) {

			if (!gb->async)

				send_count = 0;

			else if (gb->iteration_count == gb->iteration_max)

			gb->type = 0;

			send_count = 0;

			mutex_unlock(&gb->mutex);

			continue;
@@ -985,15 +965,10 @@ static int gb_loopback_fn(void *data) 
		type = gb->type;

		mutex_unlock(&gb->mutex);



		if (gb->ts.tv_usec == 0 && gb->ts.tv_sec == 0)

			do_gettimeofday(&gb->ts);



		/* Else operations to perform */

		if (gb->async) {

			if (type == GB_LOOPBACK_TYPE_PING) {

				error = gb_loopback_async_ping(gb);

				if (!error)

					gb->requests_completed++;

				gb_loopback_calculate_stats(gb);

			} else if (type == GB_LOOPBACK_TYPE_TRANSFER) {

				error = gb_loopback_async_transfer(gb, size);
@@ -1014,8 +989,6 @@ static int gb_loopback_fn(void *data) 


			if (error)

				gb->error++;

			else

				gb->requests_completed++;

			gb->iteration_count++;

			gb_loopback_calculate_stats(gb);

		}