Optimized organization of Bucketable instances

Introduced properties

type BUCKET: HashSet[Bucketable[G]]

bucketed_game :: Buckets :: BUCKET

Bucket type used in this implementation.
fun add_at(e: Bucketable[G], at_tick: Int)

bucketed_game :: Buckets :: add_at

Add the Bucketable event e at at_tick.
fun n_buckets: Int

bucketed_game :: Buckets :: n_buckets

Number of buckets, default at 100
protected fun n_buckets=(n_buckets: Int)

bucketed_game :: Buckets :: n_buckets=

Number of buckets, default at 100
fun stats: String

bucketed_game :: Buckets :: stats

Get some statistics on both the current held events and historic expired events

Redefined properties

redef type SELF: Buckets[G]

bucketed_game $ Buckets :: SELF

Type of this instance, automatically specialized in every class
redef fun core_serialize_to(v: Serializer)

bucketed_game $ Buckets :: core_serialize_to

Actual serialization of self to serializer
redef fun do_turn(turn: GameTurn[G])

bucketed_game $ Buckets :: do_turn

Execute turn for this instance.
redef init from_deserializer(v: Deserializer)

bucketed_game $ Buckets :: from_deserializer

Create an instance of this class from the deserializer

All properties

fun !=(other: nullable Object): Bool

core :: Object :: !=

Have self and other different values?
fun ==(other: nullable Object): Bool

core :: Object :: ==

Have self and other the same value?
type BUCKET: HashSet[Bucketable[G]]

bucketed_game :: Buckets :: BUCKET

Bucket type used in this implementation.
type CLASS: Class[SELF]

core :: Object :: CLASS

The type of the class of self.
type SELF: Object

core :: Object :: SELF

Type of this instance, automatically specialized in every class
protected fun accept_json_serializer(v: JsonSerializer)

serialization :: Serializable :: accept_json_serializer

Refinable service to customize the serialization of this class to JSON
protected fun accept_msgpack_attribute_counter(v: AttributeCounter)

serialization :: Serializable :: accept_msgpack_attribute_counter

Hook to customize the behavior of the AttributeCounter
protected fun accept_msgpack_serializer(v: MsgPackSerializer)

serialization :: Serializable :: accept_msgpack_serializer

Hook to customize the serialization of this class to MessagePack
fun add_at(e: Bucketable[G], at_tick: Int)

bucketed_game :: Buckets :: add_at

Add the Bucketable event e at at_tick.
protected fun add_to_bundle(bundle: NativeBundle, key: JavaString)

serialization :: Serializable :: add_to_bundle

Called by []= to dynamically choose the appropriate method according
protected fun class_factory(name: String): CLASS

core :: Object :: class_factory

Implementation used by get_class to create the specific class.
fun class_name: String

core :: Object :: class_name

The class name of the object.
fun core_serialize_to(serializer: Serializer)

serialization :: Serializable :: core_serialize_to

Actual serialization of self to serializer
abstract fun do_turn(turn: GameTurn[G])

bucketed_game :: Turnable :: do_turn

Execute turn for this instance.
init from_deserializer(deserializer: Deserializer)

serialization :: Serializable :: from_deserializer

Create an instance of this class from the deserializer
fun get_class: CLASS

core :: Object :: get_class

The meta-object representing the dynamic type of self.
fun hash: Int

core :: Object :: hash

The hash code of the object.
init init

core :: Object :: init

fun inspect: String

core :: Object :: inspect

Developer readable representation of self.
protected fun inspect_head: String

core :: Object :: inspect_head

Return "CLASSNAME:#OBJECTID".
intern fun is_same_instance(other: nullable Object): Bool

core :: Object :: is_same_instance

Return true if self and other are the same instance (i.e. same identity).
fun is_same_serialized(other: nullable Object): Bool

core :: Object :: is_same_serialized

Is self the same as other in a serialization context?
intern fun is_same_type(other: Object): Bool

core :: Object :: is_same_type

Return true if self and other have the same dynamic type.
protected fun msgpack_extra_array_items: Int

serialization :: Serializable :: msgpack_extra_array_items

Hook to request a larger than usual metadata array
fun n_buckets: Int

bucketed_game :: Buckets :: n_buckets

Number of buckets, default at 100
protected fun n_buckets=(n_buckets: Int)

bucketed_game :: Buckets :: n_buckets=

Number of buckets, default at 100
intern fun object_id: Int

core :: Object :: object_id

An internal hash code for the object based on its identity.
fun output

core :: Object :: output

Display self on stdout (debug only).
intern fun output_class_name

core :: Object :: output_class_name

Display class name on stdout (debug only).
fun serialization_hash: Int

core :: Object :: serialization_hash

Hash value use for serialization
fun serialize_msgpack(plain: nullable Bool): Bytes

serialization :: Serializable :: serialize_msgpack

Serialize self to MessagePack bytes
fun serialize_to(serializer: Serializer)

serialization :: Serializable :: serialize_to

Serialize self to serializer
fun serialize_to_json(plain: nullable Bool, pretty: nullable Bool): String

serialization :: Serializable :: serialize_to_json

Serialize self to JSON
fun stats: String

bucketed_game :: Buckets :: stats

Get some statistics on both the current held events and historic expired events
intern fun sys: Sys

core :: Object :: sys

Return the global sys object, the only instance of the Sys class.
fun to_json: String

serialization :: Serializable :: to_json

Serialize self to plain JSON
abstract fun to_jvalue(env: JniEnv): JValue

core :: Object :: to_jvalue

fun to_pretty_json: String

serialization :: Serializable :: to_pretty_json

Serialize self to plain pretty JSON
fun to_s: String

core :: Object :: to_s

User readable representation of self.
package_diagram bucketed_game::Buckets Buckets bucketed_game::Turnable Turnable bucketed_game::Buckets->bucketed_game::Turnable serialization::Serializable Serializable bucketed_game::Turnable->serialization::Serializable ...serialization::Serializable ... ...serialization::Serializable->serialization::Serializable

Ancestors

interface Object

core :: Object

The root of the class hierarchy.
interface Serializable

serialization :: Serializable

Instances of this class can be passed to Serializer::serialize

Parents

abstract class Turnable[G: Game]

bucketed_game :: Turnable

Something acting on the game

Class definitions

bucketed_game $ Buckets
# Optimized organization of `Bucketable` instances
class Buckets[G: Game]
	super Turnable[G]

	# Bucket type used in this implementation.
	type BUCKET: HashSet[Bucketable[G]]

	private var next_bucket: nullable BUCKET = null
	private var current_bucket_key = -1

	# Number of `buckets`, default at 100
	#
	# Must be set prior to using any other methods of this class.
	var n_buckets = 100

	private var buckets: Array[BUCKET] =
		[for b in n_buckets.times do new HashSet[Bucketable[G]]] is lazy

	# Stats on delays asked when adding an event with `act_in` and `act_next`
	private var delays = new Counter[Int]

	# Add the Bucketable event `e` at `at_tick`.
	fun add_at(e: Bucketable[G], at_tick: Int)
	do
		var at_key = key_for_tick(at_tick)

		if at_key == current_bucket_key then
			next_bucket.as(not null).add(e)
		else
			buckets[at_key].add(e)
		end

		e.act_at = at_tick
	end

	private fun key_for_tick(at_tick: Int): Int
	do
		return at_tick % buckets.length
	end

	redef fun do_turn(turn: GameTurn[G])
	do
		current_bucket_key = key_for_tick(turn.tick)
		var current_bucket = buckets[current_bucket_key]

		var next_bucket = new HashSet[Bucketable[G]]
		buckets[current_bucket_key] = next_bucket
		self.next_bucket = next_bucket

		for e in current_bucket do
			var act_at = e.act_at
			if act_at != null then
				if turn.tick == act_at then
					e.do_turn(turn)
				else if act_at > turn.tick and
					key_for_tick(act_at) == current_bucket_key
				then
					next_bucket.add(e)
				end
			end
		end
	end

	# Get some statistics on both the current held events and historic expired events
	fun stats: String
	do
		var entries = 0
		var instances = new HashSet[Bucketable[G]]
		var max = 0
		var min = 100000
		for bucket in buckets do
			var len = bucket.length
			entries += len
			instances.add_all bucket
			min = min.min(len)
			max = max.max(len)
		end
		var avg = entries.to_f / buckets.length.to_f

		return "{buckets.length} buckets; uniq/tot:{instances.length}/{entries}, avg:{avg.to_precision(1)}, min:{min}, max:{max}\n" +
			"history:{delays.sum}, avg:{delays.avg}, min:{delays[delays.min.as(not null)]}, max:{delays[delays.max.as(not null)]}"
	end
end
lib/bucketed_game/bucketed_game.nit:51,1--133,3