spinn_front_end_common.interface.buffer_management.storage_objects package

Module contents

class spinn_front_end_common.interface.buffer_management.storage_objects.BufferDatabase(database_file: str | None = None, *, read_only: bool = False, row_factory: type | None = <class 'sqlite3.Row'>, text_factory: type | None = <class 'memoryview'>)

Bases: BaseDatabase

Specific implementation of the Database for SQLite 3.

There should only ever be a single Database Object in use at any time. In the case of application_graph_changed the first should closed and a new one created.

If 2 database objects where opened with the database_file they hold the same data. Unless someone else deletes that file.

Note

Not thread safe on the same database file! Threads can access different DBs just fine.

Parameters:

database_file (str) – The name of a file that contains (or will contain) an SQLite database holding the data. If omitted the default location will be used.

clear_region(x: int, y: int, p: int, region: int) bool[source]

Clears the data for a single region.

Note

This method loses information!

Parameters:
  • x (int) – x coordinate of the chip

  • y (int) – y coordinate of the chip

  • p (int) – Core within the specified chip

  • region (int) – Region containing the data to be cleared

Returns:

True if any region was changed

Return type:

bool

get_core_name(x: int, y: int, p: int) str | None[source]
get_region_data(x: int, y: int, p: int, region: int) Tuple[memoryview, bool][source]

Get the data stored for a given region of a given core.

Parameters:
  • x (int) – x coordinate of the chip

  • y (int) – y coordinate of the chip

  • p (int) – Core within the specified chip

  • region (int) – Region containing the data

Returns:

A buffer containing all the data received during the simulation, and a flag indicating if any data was missing.

Note

Implementations should not assume that the total buffer is necessarily shorter than 1GB.

Return type:

tuple(memoryview, bool)

store_data_in_region_buffer(x: int, y: int, p: int, region: int, missing: bool, data: bytes)[source]

Store some information in the corresponding buffer for a specific chip, core and recording region.

Parameters:
  • x (int) – x coordinate of the chip

  • y (int) – y coordinate of the chip

  • p (int) – Core within the specified chip

  • region (int) – Region containing the data to be stored

  • missing (bool) – Whether any data is missing

  • data (bytearray) –

    data to be stored

    Note

    Must be shorter than 1GB

store_vertex_labels() None[source]
write_session_credentials_to_db() None[source]

Write Spalloc session credentials to the database if in use.

class spinn_front_end_common.interface.buffer_management.storage_objects.BufferedSendingRegion

Bases: object

A set of keys to be sent at given timestamps for a given region of data.

Note

Keys must be added in timestamp order or else an exception will be raised.

add_key(timestamp: int, key: int)[source]

Add a key to be sent at a given time.

Parameters:
  • timestamp (int) – The time at which the key is to be sent

  • key (int) – The key to send

add_keys(timestamp: int, keys: Iterable[int])[source]

Add a set of keys to be sent at the given time.

Parameters:
  • timestamp (int) – The time at which the keys are to be sent

  • keys (iterable(int)) – The keys to send

clear() None[source]

Clears the buffer.

property current_timestamp: int

The current timestamp in the iterator.

Return type:

int

get_n_keys(timestamp: int) int[source]

Get the number of keys for a given timestamp.

Parameters:

timestamp – the time stamp to check if there’s still keys to transmit

is_next_key(timestamp: int) bool[source]

Determine if there is another key for the given timestamp.

Parameters:

timestamp (int) – the time stamp to check if there’s still keys to transmit

property is_next_timestamp: bool

Whether the region is empty.

Returns:

True if the region is empty, false otherwise.

Return type:

bool

property n_timestamps: int

The number of timestamps available.

Return type:

int

property next_key: int

The next key to be sent. Only call if is_next_key() returns True.

Return type:

int

property next_timestamp: int | None

The next timestamp of the data to be sent, or None if no more data.

Return type:

int or None

rewind() None[source]

Rewind the buffer to initial position.

property timestamps: Sequence[int]

The timestamps for which there are keys.

Return type:

iterable(int)

class spinn_front_end_common.interface.buffer_management.storage_objects.BuffersSentDeque(region: int, sent_stop_message: bool = False, n_sequences_per_tranmission: int = 64)

Bases: object

A tracker of buffers sent / to send for a region

Parameters:
  • region (int) – The region being managed

  • sent_stop_message (bool) – True if the stop message has been sent

  • n_sequences_per_tranmission (int) – The number of sequences allowed in each transmission set

add_message_to_send(message: AbstractEIEIOMessage)[source]

Add a message to send. The message is converted to a sequenced message.

Parameters:

message (AbstractEIEIOMessage) – The message to be added

is_empty() bool[source]

Determine if there are no messages.

Return type:

bool

property is_full: bool

Whether the number of messages sent is at the limit for the sequencing system.

Return type:

bool

property messages: Iterable[HostSendSequencedData]

The messages that have been added to the set.

Return type:

iterable(HostSendSequencedData)

send_stop_message() None[source]

Send a message to indicate the end of all the messages.

update_last_received_sequence_number(last_received_sequence_no: int) bool[source]

Updates the last received sequence number. If the sequence number is within the valid window, packets before the sequence number within the window are removed, and the last received sequence number is updated, thus moving the window for the next call. If the sequence number is not within the valid window, it is assumed to be invalid and so is ignored.

Parameters:

last_received_sequence_no (int) – The new sequence number

Returns:

True if update went ahead, False if it was ignored

Return type:

bool