Sur site ou dans le Cloud ?
Rix — Moteur d'agrégation distribuée
Développez des agrégations pour XVA, FRBT, SA-CCR sans les contraintes techniques – quelques heures suffisent
Rix est un moteur d'agrégation conçu pour répondre aux dernières réglementations
Prêt pour XVA, FRTB, SA-CCR, IRRBB, IM
Implémentation rapide
La création d’une agrégation complexe se paramètre en quelques jours seulement, avec des outils dédiés
Langage intuitif
Langage simplifié de définition d’agrégation (ADL) orienté finance sans contrainte de programmation
Haute performance
Calculs distribués rapides et gestion intelligente de la mémoire
Comment ça marche
L'utilisateur définit l'agrégation
Le langage de définition d'agrégation (Rix ADL) permet à l'utilisateur de définir l'agrégation en termes financiers sans aucune connaissance de l'exécution distribuée ou parallèle, comme par exemple gestion de la mémoire sur de gros volumes de données.
L'agrégation est compilée à la volée
Le fichier d'agrégation nouvellement créé ou modifié est téléchargé sur le système. Il est interprété à la volée : aucune recompilation ni redéploiement n'est nécessaire
Le moteur exécute l'agrégation dans le cloud
L'agrégation nouvellement arrivée est automatiquement distribuée sur le Cloud et exécutée efficacement sans aucune action supplémenta
Choix technologiques
Distribué, multiplateformes, compatible cloud
Nous avons choisi la meilleure technologie disponible pour rendre la solution distribuée rapide, fiable et véritablement multiplateforme.
La solution est compatible cloud et déverrouillée pour tous systèmes. Qu’il s’agisse d’un cloud public ou d’un cluster sur site, le déploiement automatique avec Ansible et la possibilité de livrer sur conteneurs Docker rendront le déploiement facile et reproductible sur tous vos environnements.
Qu'est-ce qui le rend si innovant?
Séparation des détails techniques et fonctionnels
La définition d’agrégation est exprimée en termes financiers et n’implique aucune instruction d’exécution.
Distribution automatique
L’exécution de l’agrégation est distribuée automatiquement en utilisant au maximum la structure du problème et en tenant compte de la nature des calculs.
Gestion intelligente de la mémoire
Les données sont agrégées au fil de l’eau afin de maîtriser l’utilisation mémoire, ce qui permet de gérer des calculs demandant des téraoctets de prix et de courbes.
Interchangeabilité du middleware de distribution
La mise en œuvre par défaut est proposée sur Apache Ignite ™ mais peut être remplacée par n’importe quel middleware de distribution grâce à un ensemble exhaustif d’abstractions et d’interfaces.
Langage de définition d'agrégation
Le langage de définition d’agrégation Rix vous permet de définir rapidement des agrégations complexes sans en connaître les aspects techniques. Il vous suffit de définir vos hiérarchies, vos métriques, vos formules et d’essayer.
*Click on the code to stop/start the animation
<Hierarchy Name="Portfolio" Fact="TradeFact">
<Levels>
<Level Name="Portfolio" Child="Pty" ConstValue="Portfolio" />
<Level Name="Pty" Child="Cpty" Field="PartyId" />
<Level Name="Cpty" Field="CounterpartyId" >
<Send To="NoCS" When="#CollateralSetId eq null"/>
<ElseSend To="CS"/>
</Level>
<Level Name="CS" Child="Trade" Field="CollateralSetId" />
<Level Name="NoCS" Child="Trade" ConstValue="NoCS" />
<Level Name="Trade" Field="TradeId" />
</Levels>
</Hierarchy>
*Click on the code to stop/start the animation
<Metrics>
<Metric Name="NPV" Type="Scalar" />
<Metric Name="PG" Type="Grid" IsVolatile="true" />
<Metric Name="EMTM" Type="Profile" />
<Metric Name="EPE" Type="Profile" />
<Metric Name="ENE" Type="Profile" />
</Metrics>
*Click on the code to stop/start the animation
<Aggregation>
<Bindings Level="Trade">
...
<Bind Metric="NPV" To="$EMTM[0]" />
</Bindings>
...
<Bindings Level="CS">
...
<Bind Metric="CVA" To="CVA-DVA-Spot($EPE, @Cpty:DefaultProba, @Cpty:RecoveryRate)">
<Bind Metric="DVA" To="CVA-DVA-Spot($ENE, @Pty:DefaultProba, @Pty:RecoveryRate)">
</Bindings>
</Aggregation>
*Click on the code to stop/start the animation
<Bindings Level="CS">
...
<Conditions>
<When Condition="($csa.Direction eq 'Party')">
<Bind Metric="EPE-Grid" To="$EPE-Grid2"/>
<Bind Metric="EPE" To="$EPE2"/>
</When>
<When Condition="($csa.Direction eq 'Counterparty')">
<Bind Metric="ENE-Grid" To="$ENE-Grid2"/>
<Bind Metric="ENE" To="$ENE2"/>
</When>
</Conditions>
</Bindings>
*Click on the code to stop/start the animation
<Aggregation ForPass="1">
<Bindings Level="Trade">
...
<Bind Metric="NPV" To="$EMTM[0]" />
</Bindings>
...
<Bindings Level="CS">
...
<Bind Metric="CVA" To="CVA-DVA-Spot($EPE, @Cpty:DefaultProba, @Cpty:RecoveryRate)">
<Bind Metric="DVA" To="CVA-DVA-Spot($ENE, @Pty:DefaultProba, @Pty:RecoveryRate)">
</Bindings>
</Aggregation>
<Aggregation ForPass="2">
<Bindings Level="Trade">
<Bind Metric="CVA" To="($NPV / @CS:NPV) * @CS:CVA" />
</Bindings>
</Aggregation>
API
Un ensemble d’API vous permet d’implémenter vos propres fonctions de calcul et d’agrégation. L’API de streaming vous permet d’injecter progressivement des données dans l’agrégateur.
*Click on the code to stop/start the animation
[RixFunc("CVA-DVA")]
public sealed class ComputeCvaDva
{
[RixCall]
public double Call(
ICurve<Date> exposure, ICurve<Date> dps, double rr, CurrencyIso currency,
[RixTechnical] IAggregationGlobalContext ctx)
{
var dsc = gCtx.Market.Get<InterestRateCurve>(index).DiscountCurve;
var axis = exposure.Axis;
double cvaDva = 0d;
for (int j = 1; j < axis.Count; j++)
{
var dp = dps[j] - dps[j - 1] > 0 ? dps[j] - dps[j - 1] : 0.0;
cvaDva += (exposure[axis[j]]* dsc[j] + dsc[j - 1]*exposure[axis[j-1]]) * 0.5d * dp;
}
cvaDva *= (1 - rr);
return cvaDva;
}
*Click on the code to stop/start the animation
[RixFunc("Avg", RixFunctionType.Aggregator, OptimizeCalls = true)] // Mark the class as aggregator
public sealed class DoubleAvgAggregate :
IAggregate<DoubleAvgAggregate.AvgDoubleMutableAcc, double> // Define the type of accumulator and result
{
public class AvgDoubleMutableAcc { // Define accumulator class
public double Sum;
public int Count;
public AvgDoubleMutableAcc(double sum, int count)
{
if (count < 0) throw new ArgumentOutOfRangeException(nameof(count));
Sum = sum;
Count = count;
}
}
// Accumulator creation method
public AvgDoubleMutableAcc CreateAccumulator(IAggregateContext ctx) => new AvgDoubleMutableAcc(0, 0);
// Updating accumulator on new metrics
public void Update(AvgDoubleMutableAcc acc, double metric, IAggregateContext ctx) {
acc.Sum += metric;
acc.Count++;
}
// Merges two accumulators
public void Merge(AvgDoubleMutableAcc target, AvgDoubleMutableAcc source, IAggregateContext ctx) {
target.Sum += source.Sum;
target.Count += source.Count;
}
// Computes final metrics
public double Evaluate(AvgDoubleMutableAcc acc, IAggregateContext ctx) => acc.Sum / acc.Count;
}
*Click on the code to stop/start the animation
var structure = RixApi // We use RIX API to aggregate
.LoadFromFile("aggregation.xml") // Load aggregation file
.Compile(functions) // Compile with user-defined functions
.BuildStructure(trades); // Build tree structure using trades
var dataStore = structure.CreateDataStore(); // Create data store (for metrics)
var aggregationScope = structure.CreateScope() // Create scope
.WithGlobalVariable("PFE_Confidence", 95); // with global variables
var slice = aggregationScope.CreateSlice("CS"); // Create slice for collateral set level
using (var stream = slice.CreateStream( // Create aggregation stream
collateralSetId, // for certain collateral set
dataStore)) // and data store
{
stream.Start(); // Start the stream
parallel foreach (var tradeId in tradeIds) // iterate over trade IDs in parallel
{
var trade = FetchTrade(tradeId); // get trade from DB, cache, file etc.
var pricingGrid = MonteCarlo(trade); // simulate Monte-Carlo prices
stream.PushData( // push data to the stream
tradeId, // for the particular trade
Fact.WithField("PG", pricingGrid); // with "PG" field
}
stream.CompleteStreaming(); // Complete stream (all data is in)
}
await stream.WaitTask; // Wait for the stream to finish
Articles
Rix est décrit avec plus en détails dans ce whitepaper. Vous y trouverez :
- Informations rapides
- Détails techniques
- Analyse des performances
- Exemple de langage définissant l’agrégation
- Exemple de code de streaming
