fn_registry/cpp/functions/datascience/mc_session_sim_gpu.md

name, kind, lang, domain, version, purity, signature, description, tags, uses_functions, uses_types, returns, returns_optional, error_type, imports, tested, tests, test_file_path, file_path, framework, params, output

name	kind	lang	domain	version	purity	signature	description	tags	uses_functions	uses_types	returns	returns_optional	error_type	imports	tested	tests	test_file_path	file_path	framework	params	output
mc_session_sim_gpu	function	cpp	datascience	1.0.0	impure	McSessionSim mc_session_sim_create(int n_sessions, int max_tiers); void mc_session_sim_reseed(McSessionSim&, uint64 seed); void mc_session_sim_run(McSessionSim&, const McSessionParams&); void mc_session_sim_readback_summary(const McSessionSim&, float* out); void mc_session_sim_readback_tier_counts(const McSessionSim&, unsigned int* out); void mc_session_sim_destroy(McSessionSim&)	N sesiones independientes de K spins en paralelo en GPU (1 thread = 1 sesion). Implementa el modelo variable-ratio escalonado de vr_tiered_lab: tiers (q, m), modes Pure/Pity/Streak, miss_streak, drawdown. Output SSBOs: summary[N*8] + tier_counts[N*max_tiers].	montecarlo gpu simulation vr_tiered sessions datascience	gl_loader_cpp_gfx gpu_ssbo_cpp_gfx gpu_compute_program_cpp_gfx gpu_dispatch_cpp_gfx gpu_rng_glsl_cpp_gfx			false	error_go_core	GL/gl.h GL/glext.h vector cstdio	false			cpp/functions/datascience/mc_session_sim_gpu.cpp	opengl	name desc n_sessions Numero de sesiones independientes a simular en paralelo. 1 thread por sesion. Tipico: 10^4 - 10^6. name desc max_tiers Maximo de tiers que el simulador soportara (cota dura del shader = 8). Reservar el max que necesites; los runs pueden usar menos. name desc master_seed Semilla base. Cada sesion deriva su PCG state via SplitMix64 (deterministico bit-exacto). name desc p McSessionParams: p_base, cost, start_balance, n_spins, n_tiers (<= max_tiers), tiers_q[n_tiers], tiers_m[n_tiers], mode, mode_p1, mode_p2. name desc out (summary) float[N*8]; (tier_counts) uint[N*max_tiers].	Tras run, summary tiene 8 floats por sesion: [final_balance, pnl, max_dd, peak, trough, spins, wins, longest_miss]. tier_counts tiene un uint por (sesion, tier_idx). El SSBO de seeds se actualiza para permitir runs subsiguientes que continuen la cadena RNG.

mc_session_sim_gpu

Kernel GPU que portea el simulador de sesiones de vr_tiered_lab_v2.jsx. Cada sesion vive entera en un thread con state local en registros — sin atomics, sin shared memory, paralelismo trivial.

Performance esperada

RTX 3070, 5888 cores: 10^6 sesiones × 10^4 spins = 10^10 ops Monte Carlo en ~1-3 s. Comparado con CPU single-thread (~60 s) el speedup es 20-60x.

Patron de uso

auto sim = fn::ds::mc_session_sim_create(/*n_sessions=*/100'000, /*max_tiers=*/5);
fn::ds::mc_session_sim_reseed(sim, 0xC0FFEE);

// Mid vol preset
float qs[] = {0.7f, 0.22f, 0.07f, 0.01f};
float ms[] = {1.5f, 4.0f, 15.0f, 100.0f};

fn::ds::McSessionParams p{};
p.p_base        = 0.20f;
p.cost          = 1.0f;
p.start_balance = 100.0f;
p.n_spins       = 1000;
p.n_tiers       = 4;
p.tiers_q       = qs;
p.tiers_m       = ms;
p.mode          = fn::ds::McSessionMode::Pity;
p.mode_p1       = 5.0f;       // pity soft = 5 misses
p.mode_p2       = 20.0f;      // pity hard = 20 misses

fn::ds::mc_session_sim_run(sim, p);

std::vector<float> summary(100'000 * 8);
fn::ds::mc_session_sim_readback_summary(sim, summary.data());

// summary[sid*8 + 1] = pnl de la sesion sid
// histograma de pnl para distribucion -> stats_summary, drawdown, etc.

fn::ds::mc_session_sim_destroy(sim);

Modes

mode	mode_p1	mode_p2	Descripcion
Pure	—	—	p_eff = p_base (sin compensacion)
Pity	soft	hard	p_eff sube linealmente p_base->1 entre soft y hard miss_streak
Streak	lambda	—	p_eff = min(1, p_base * (1 + lambda * miss_streak))

Layout summary[sid * 8 + k]

k	Campo
0	final_balance
1	pnl (= final - start)
2	max_dd (peak-to-trough absoluto)
3	peak
4	trough
5	spins (= n_spins o menor si rota antes por ruina)
6	wins (numero de hits)
7	longest_miss

Notas

• max_tiers esta cap a 8 (cota dura del shader, registros locales). Si necesitas mas, usar variante con SSBO de counters por sesion en vez de registros.
• Tras run, el SSBO de seeds RNG queda actualizado. Llamar run otra vez con n_spins adicional simula los siguientes spins continuando la cadena (no rearranca). Util para "stream" sesiones largas en chunks.
• Para batches mas grandes que VRAM (n_sessions > 10^7 con summary float[8] = 320 MB), partir en sub-batches y readback entre llamadas.
• Compatibilidad GL 4.3+ (compute shaders + atomicAdd uint). RTX 3070 expone GL 4.6, sobra.