~lttng/lttng-ust/lttng-ust

Viewing changes to src/common/ringbuffer/ring_buffer_frontend.c

Committer: Mathieu Desnoyers
Date: 2024-05-03 19:32:50 UTC
Revision ID: git-v1:373ea80ac0db5072e995140f1dbdbf4f0b1bdaad

Rename "tsc" to "timestamp"

Naming timestamps "TSC" or "tsc" is an historical artefact dating from
the implementation of libringbuffer, where the initial intent was to use
the x86 "rdtsc" instruction directly, which ended up not being what was
done in reality.

Rename uses of "TSC" and "tsc" to "timestamp" to clarify things and
don't require reviewers to be fluent in x86 instruction set.

Signed-off-by: Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
Change-Id: I8e7e2ad9cd2d2427485fc6adbc340fccde14ca2f

files modified:
src/common/ringbuffer-clients/metadata-template.h

src/common/ringbuffer-clients/template.h

src/common/ringbuffer/backend_types.h

src/common/ringbuffer/frontend_api.h

src/common/ringbuffer/frontend_internal.h

src/common/ringbuffer/frontend_types.h

src/common/ringbuffer/ring_buffer_backend.c

src/common/ringbuffer/ring_buffer_frontend.c

src/common/ringbuffer/ringbuffer-config.h

Show diffs side-by-side

added added

removed removed

src/common/ringbuffer/ring_buffer_frontend.c

203

}

204

uatomic_set(&buf->consumed, 0);

205

uatomic_set(&buf->record_disabled, 0);

206

v_set(config, &buf->last_tsc, 0);

206

v_set(config, &buf->last_timestamp, 0);

207

lib_ring_buffer_backend_reset(&buf->backend, handle);

208

/* Don't reset number of active readers */

209

v_set(config, &buf->records_lost_full, 0);

341

struct commit_counters_hot *cc_hot;

342

void *priv = channel_get_private_config(chan);

343

size_t subbuf_header_size;

344

uint64_t tsc;

344

uint64_t timestamp;

345

int ret;

346

347

/* Test for cpu hotplug */

398

ret = -EPERM;

399

goto free_chanbuf;

400

}

401

tsc = config->cb.ring_buffer_clock_read(shmp_chan);

402

config->cb.buffer_begin(buf, tsc, 0, handle);

401

timestamp = config->cb.ring_buffer_clock_read(shmp_chan);

402

config->cb.buffer_begin(buf, timestamp, 0, handle);

403

cc_hot = shmp_index(handle, buf->commit_hot, 0);

404

if (!cc_hot) {

405

ret = -EPERM;

1774

unsigned long commit_count;

1775

struct commit_counters_hot *cc_hot;

1776

1777

config->cb.buffer_begin(buf, ctx->priv->tsc, oldidx, handle);

1777

config->cb.buffer_begin(buf, ctx->priv->timestamp, oldidx, handle);

1778

1779

1780

* Order all writes to buffer before the commit count update that will

1832

* postponed until the commit counter is incremented for the

1833

* current space reservation.

1834

1835

*ts_end = ctx->priv->tsc;

1835

*ts_end = ctx->priv->timestamp;

1836

1837

1838

* Order all writes to buffer and store to ts_end before the commit

1870

unsigned long commit_count;

1871

struct commit_counters_hot *cc_hot;

1872

1873

config->cb.buffer_begin(buf, ctx->priv->tsc, beginidx, handle);

1873

config->cb.buffer_begin(buf, ctx->priv->timestamp, beginidx, handle);

1874

1875

1876

* Order all writes to buffer before the commit count update that will

1924

* postponed until the commit counter is incremented for the

1925

* current space reservation.

1926

1927

*ts_end = ctx->priv->tsc;

1927

*ts_end = ctx->priv->timestamp;

1928

}

1929

1930

1948

offsets->switch_old_start = 0;

1949

off = subbuf_offset(offsets->begin, chan);

1950

1951

ctx->priv->tsc = config->cb.ring_buffer_clock_read(chan);

1951

ctx->priv->timestamp = config->cb.ring_buffer_clock_read(chan);

1952

1953

1954

* Ensure we flush the header of an empty subbuffer when doing the

2084

!= offsets.old);

2085

2086

2087

* Atomically update last_tsc. This update races against concurrent

2088

* atomic updates, but the race will always cause supplementary full TSC

2089

* records, never the opposite (missing a full TSC record when it would

2090

* be needed).

2087

* Atomically update last_timestamp. This update races against concurrent

2088

* atomic updates, but the race will always cause supplementary full

2089

* timestamp records, never the opposite (missing a full timestamp

2090

* record when it would be needed).

2091

2092

save_last_tsc(config, buf, ctx.priv->tsc);

2092

save_last_timestamp(config, buf, ctx.priv->timestamp);

2093

2094

2095

* Push the reader if necessary

2158

offsets->switch_old_end = 0;

2159

offsets->pre_header_padding = 0;

2160

2161

ctx_private->tsc = config->cb.ring_buffer_clock_read(chan);

2162

if ((int64_t) ctx_private->tsc == -EIO)

2161

ctx_private->timestamp = config->cb.ring_buffer_clock_read(chan);

2162

if ((int64_t) ctx_private->timestamp == -EIO)

2163

return -EIO;

2164

2165

if (last_tsc_overflow(config, buf, ctx_private->tsc))

2166

ctx_private->rflags |= RING_BUFFER_RFLAG_FULL_TSC;

2165

if (last_timestamp_overflow(config, buf, ctx_private->timestamp))

2166

ctx_private->rflags |= RING_BUFFER_RFLAG_FULL_TIMESTAMP;

2167

2168

if (caa_unlikely(subbuf_offset(offsets->begin, chan) == 0)) {

2169

offsets->switch_new_start = 1; /* For offsets->begin */

2371

!= offsets.old));

2372

2373

2374

* Atomically update last_tsc. This update races against concurrent

2375

* atomic updates, but the race will always cause supplementary full TSC

2376

* records, never the opposite (missing a full TSC record when it would

2377

* be needed).

2374

* Atomically update last_timestamp. This update races against concurrent

2375

* atomic updates, but the race will always cause supplementary full

2376

* timestamp records, never the opposite (missing a full timestamp

2377

* record when it would be needed).

2378

2379

save_last_tsc(config, buf, ctx_private->tsc);

2379

save_last_timestamp(config, buf, ctx_private->timestamp);

2380

2381

2382

* Push the reader if necessary

Older »