ForHosting KIT · Outils pour développeurs

Calculateur de latence RAM

Transformez la latence CAS et l'horloge d'un kit mémoire en temps réel : CL16 à 1600 MHz, vendu comme DDR4-3200, met 10 ns à livrer le premier mot. Des kits aux cycles et aux fréquences différents se comparent enfin sur la même échelle. Gratuit dans votre navigateur.

Gratuit
Fonctionne dans votre navigateur
Sans inscription
Vos données restent sur votre appareil

Lancer gratuitement Voir l’API

Utilisez-le depuis WebAPIE-mailTelegramApp bientôt

Exemple résolu

Si vous saisissez

Latence CAS: 16
Horloge (MHz): 1 600

Vous obtenez

Période d'horloge (ns): 0,625
Latence du premier mot (ns): 10

La latence réelle de la RAM est le temps, en nanosecondes, jusqu'à ce que le premier mot d'une rafale DRAM devienne disponible après un strobe d'adresse de colonne. Les étiquettes des modules et les fiches d'achat annoncent la latence CAS comme un entier de cycles d'horloge à côté d'une fréquence en mégahertz, et ces deux nombres masquent le délai qui gouverne vraiment la réactivité tant que l'on n'a pas converti les cycles en temps.

Ce qu'est la latence RAM du premier mot et comment CAS devient des nanosecondes

La latence RAM du premier mot est le délai d'accès colonne : combien de nanosecondes s'écoulent entre une adresse de colonne valide et le premier beat de données sur le bus DQ. Les feuilles de timings JEDEC impriment ce délai comme latence CAS, un entier de cycles d'horloge DRAM, à côté d'une fréquence d'horloge en mégahertz. Les cycles ne sont pas du temps.

Deux kits avec le même CL peuvent sembler différents parce que leurs horloges diffèrent ; deux kits avec un CL distinct peuvent sembler identiques si l'horloge plus rapide raccourcit assez la période pour annuler les cycles en trop. La conversion est une seule division. La période d'horloge tCK en nanosecondes vaut mille divisé par l'horloge en mégahertz, car un mégahertz fait un million de cycles par seconde et une nanoseconde est un milliardième de seconde.

Exemple résolu : un module DDR4 dont l'horloge de commande est 1600 MHz, commercialisé en DDR4-3200, avec CL16 a tCK égal à 1000/1600 = 0.625 ns et une latence du premier mot 16 × 0.625 = 10 ns. Le même CL16 à une horloge de 2000 MHz, DDR4-4000, tombe à 8 ns. Ce point de terminaison renvoie la période et le temps du premier mot afin que vous puissiez auditer l'arithmétique, pas seulement le chiffre en nanosecondes affiché par les tableaux de comparaison.

Contrat d'entrée, horloge DDR contre débit annoncé, et erreurs

Les chaînes numériques sont analysées. Un champ manquant ou non fini échoue de la même façon. La latence CAS doit être un nombre fini non négatif ; un nombre de cycles négatif est rejeté.

Les valeurs sont arrondies à douze décimales afin que goldens et clients comparent de façon stable entre runtimes JavaScript. Important : les noms DDR annoncés tels que DDR4-3200 ou DDR5-6000 sont des débits de données en mégatransferts par seconde, pas l'horloge de commande. DDR transfère deux fois par horloge, donc l'horloge en mégahertz vaut la moitié de l'indice MT/s.

Saisissez 1600 pour DDR4-3200 et 3000 pour DDR5-6000. Ce calculateur n'intègre pas tRCD, tRP, tRAS, les trous de bank-group ni les délais de commande à commande ; ces cycles supplémentaires appartiennent à un chemin d'accès aléatoire complet, pas à la latence colonne du premier mot.

Où un calculateur de latence RAM justifie vraiment son existence

Les assembleurs de PC utilisent un calculateur de latence RAM lorsque deux kits ont des prix proches et que la fiche boutique n'imprime que le CL et une vitesse façon mégahertz. Convertir les deux en nanosecondes répond si le CAS plus serré de la barrette plus lente l'emporte vraiment.

Overclockeurs et affineurs mémoire appliquent la même identité après chaque changement de BIOS : si vous montez l'horloge et laissez le CL inchangé, la latence du premier mot baisse ; si vous desserrez le CL pour garder le kit stable à une horloge plus haute, vous voyez aussitôt si les nanosecondes nettes se sont améliorées. Intégrateurs et acheteurs serveurs comparent bins JEDEC et profils EXPO ou XMP sans ouvrir un tableur.

Sites de tests et tableaux d'affiliation génèrent une colonne de latence vraie à partir de dumps SPD pour que le lecteur ne soit pas induit en erreur par un CL brut à côté d'une fréquence marketing. Un échec de validation ne consomme pas le solde. Gardez les requêtes petites, rejetez les horloges non positives à la bordure, et vous obtenez une latence du premier mot reproductible pour scripts d'achat, journaux d'overclock et workers de bord sans monter votre propre analyseur de datasheet.

Cas d’usage

Comparer des kits DIMM avant l'achat

Convertissez la latence CAS et l'horloge de commande de chaque kit en nanosecondes du premier mot pour classer un CL plus serré sur une barrette lente face à un CL plus lâche sur une plus rapide.

Régler XMP, EXPO et timings manuels

Après chaque changement d'horloge ou de CL dans le BIOS, recalculez la latence du premier mot et ne conservez le profil que lorsque le chiffre en nanosecondes s'est réellement amélioré.

Bins JEDEC serveur et station de travail

Classez les bins de vitesse de DIMM enregistrés et les tables JEDEC selon le vrai temps d'accès colonne, plutôt que selon le seul débit en mégatransferts annoncé.

Questions fréquentes

Faut-il saisir DDR4-3200 comme 3200 MHz ou comme 1600 MHz ?

Saisissez l'horloge de commande, pas le débit de données annoncé. DDR transfère deux fois par horloge, donc DDR4-3200 vaut 1600 MHz et DDR5-6000 vaut 3000 MHz.

Que se passe-t-il si la fréquence d'horloge est nulle ou négative ?

Une fréquence d'horloge non positive rend la période indéfinie, donc le calculateur la refuse et l'appel n'est pas facturé.

La latence du premier mot est-elle la même que la latence d'accès aléatoire complet ?

Non. Ce point de terminaison ne renvoie que le délai d'accès colonne CAS. Un accès aléatoire complet attend aussi tRCD, tRP, tRAS et d'autres timings de banque que ce calculateur n'inclut pas.

Comment comparer deux kits de RAM aux CL et fréquences différents ?

Convertissez les deux en nanosecondes et comparez ces chiffres. CL16 avec une horloge de 1600 MHz donne 10 ns, alors que le même CL16 à 2000 MHz, vendu comme DDR4-4000, donne 8 ns : le second livre son premier mot plus tôt.

Un CAS plus élevé signifie-t-il toujours une mémoire plus lente ?

Non. Le CAS compte des cycles d'horloge, pas du temps. Une horloge plus rapide raccourcit chaque cycle, si bien qu'un kit avec plus de cycles peut être aussi rapide, voire plus, qu'un kit avec moins de cycles et une horloge plus lente.

Outils associés

Pour les développeurs — accès API

Tout sur cette page est disponible par programmation. Cette section s'adresse aux équipes qui veulent l'intégrer à leurs systèmes ; les autres peuvent simplement utiliser l'outil ci-dessus.

Endpoint

POSThttps://api.kit.forhosting.com/dev/ram-latency

Authentification par jeton Bearer : un seul POST met la tâche en file d’attente, et le résultat vous parvient par webhook ou lien signé.

Appeler depuis votre stack

curl -X POST https://api.kit.forhosting.com/dev/ram-latency \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d '{"cas_latency":16,"clock_mhz":1600}'

const res = await fetch("https://api.kit.forhosting.com/dev/ram-latency", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.KIT_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "cas_latency": 16,
    "clock_mhz": 1600
  })
});
const { task_id } = await res.json();

import os, requests

res = requests.post(
    "https://api.kit.forhosting.com/dev/ram-latency",
    headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
    json={
    "cas_latency": 16,
    "clock_mhz": 1600
},
)
task_id = res.json()["task_id"]

<?php
$res = file_get_contents("https://api.kit.forhosting.com/dev/ram-latency", false, stream_context_create([
  "http" => [
    "method"  => "POST",
    "header"  => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
    "content" => '{"cas_latency":16,"clock_mhz":1600}',
  ],
]));
$task = json_decode($res, true);

body := bytes.NewBufferString(`{"cas_latency":16,"clock_mhz":1600}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/dev/ram-latency", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)

Exemple de requête

{
  "cas_latency": 16,
  "clock_mhz": 1600
}

Exemple de réponse

{
  "task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
  "type": "dev.ram_latency",
  "status": "queued",
  "_links": {
    "result": "/tasks/tsk_…/result"
  }
}

L’API est asynchrone : chaque appel renvoie un task_id immédiatement, puis vous interrogez l’état à raison d’une requête par seconde.

Tarifs

par requête$0.002

Le prix est publié, sans tokens ni crédits. Une tâche qui échoue n’est pas facturée.

Erreurs

HTTP	Code	Signification
`401`	`unauthorized`	Clé API absente ou invalide : vérifiez l’en-tête Authorization.
`402`	`insufficient_balance`	Solde insuffisant : rechargez votre compte pour lancer cette tâche.
`404`	`unknown_type`	Type de tâche inconnu : vérifiez le champ type de votre requête.
`429`	`rate_limited`	Trop de requêtes : ralentissez la cadence, puis réessayez.

Notes techniques

Ce calculateur de latence RAM applique l'identité du premier mot t_ns égale à CAS fois mille divisé par l'horloge en mégahertz, et renvoie le délai d'accès colonne utilisé pour comparer des kits DIMM, des profils XMP et des bins JEDEC. Saisissez le timing CAS et une horloge DRAM strictement positive en mégahertz ; une horloge nulle ou négative est rejetée comme invalid_input car la période serait indéfinie.

Ce qu'est la latence RAM du premier mot et comment CAS devient des nanosecondes

Multiplier cette période par le nombre de cycles CAS donne la latence du premier mot tCL en nanosecondes : t_ns égale cas_latency fois 1000 divisé par clock_mhz.

Contrat d'entrée, horloge DDR contre débit annoncé, et erreurs

Envoyez un JSON avec deux nombres finis obligatoires : cas_latency, le nombre de cycles CAS imprimé comme CL sur le module ou dans le SPD, et clock_mhz, l'horloge de commande DRAM en mégahertz. Les alias cas, cl et cas_cl sont acceptés pour le nombre de cycles ; clock_speed, frequency, mhz et clock le sont pour l'horloge. L'horloge doit être strictement positive : une fréquence nulle ou négative rendrait la période 1000/f indéfinie ou négative, donc la tâche échoue avec invalid_input en nommant clock_mhz et n'est pas facturée. En cas de succès le corps répète cas_latency et clock_mhz, renvoie clock_period_ns comme tCK, renvoie first_word_latency_ns comme résultat principal, et reformule la formule t_ns = cas_latency * 1000 / clock_mhz. Si vous collez 3200 comme clock_mhz vous calculerez la moitié de la vraie latence du premier mot.

Où un calculateur de latence RAM justifie vraiment son existence

Notes de firmware et scripts de mise en route épinglent les champs nanosecondes arrondis dans les tests et documentent que clock_mhz est l'horloge de commande, pas le débit DDR.

Questions techniques

Comment calcule-t-on la latence RAM du premier mot à partir de CAS et de l'horloge ?

La latence du premier mot en nanosecondes vaut cas_latency × 1000 / clock_mhz, où cas_latency est le CL en cycles d'horloge et clock_mhz l'horloge de commande DRAM en mégahertz. La période d'horloge tCK vaut 1000 / clock_mhz nanosecondes.

Combien coûte le calculateur de latence RAM ?

L'outil navigateur est gratuit. Les requêtes API utilisent un solde KIT prépayé à $0.002 par appel réussi ; une entrée invalide n'est pas facturée.

Consulter la documentation complète du KIT →