Questions sur la langue SI - page 8

Nouveau commentaire
 
 
Igor Makanu:

il existe des zones de mémoire et des pointeurs vers des zones de mémoire stockées dans d'autres zones de mémoire.

et ensuite il y a une hiérarchie aussi longtemps que le cerveau peut percevoir

 
Vladimir Simakov:
En outre, les inserts d'assemblage sont également très utilisés.

Je retire partiellement ce que j'ai dit, regardez à partir de 18:00, oui, ils n'écrivent pas en asm, mais corrigent le code déjà compilé - alors c'est logique.

d'après ce que j'ai compris, ce que font les compilateurs modernes avec des insertions en assembleur n'est qu'une imitation de l'asm, c'est-à-dire qu'il n'est pas certain que l'insertion asm sous cette forme se retrouve dans le code compilé, et pour vraiment optimiser dans le code asm il suffit de réécrire les sections de code en asm dans le debugger - imho


 
Maxim Dmitrievsky:

il existe des zones de mémoire et des pointeurs vers des zones de mémoire stockées dans d'autres zones de mémoire.

et ensuite il y a une hiérarchie aussi longtemps que le cerveau peut percevoir

Ouais, et c'est aussi cool de ne pas garder la trace de savoir si un lien est vivant ou non et de ramper dans une section de mémoire libérée depuis longtemps qui est déjà utilisée par un autre processus et de tout casser là)))).

 
Vladimir Simakov:

Ouais, et c'est aussi cool de ne pas suivre quand un lien est vivant ou non et de ramper dans un espace mémoire libéré depuis longtemps, qui est déjà utilisé par un autre processus et de tout casser là)))).

Quel conte de fées, cela n'était possible que dans Windows 3.*. Windows ne vous laissera pas accéder à la mémoire de quelqu'un d'autre, chaque processus travaille dans sa propre zone, et pour lui l'adressage de la mémoire commence à zéro, c'est ainsi qu'il est présenté par Windows. Et en général, Windows n'alloue de la mémoire que lorsqu'il écrit réellement des données. Faites un tableau double arr[1024*1024*1024] et voyez combien de mémoire est réellement allouée dans le Gestionnaire des tâches. Mais pas du tout ! Tant que vous ne commencerez pas à écrire dans le tableau, la mémoire ne sera pas allouée par tranches de 4Kb. Même si vous l'écrivez en utilisant des indices aléatoires, il sera toujours dans de tels morceaux. Comment Windows virtualise tout cela me paraît insondable !

 
Alexey Volchanskiy:

Comment Windows virtualise tout cela me paraît insondable !

Je n'ai pas envie de chercher sur Google, mais depuis l'avènement du Pentium-1, le processeur dispose de descripteurs de segments de mémoire et de mémoire virtuelle, c'est-à-dire qu'il s'agit très probablement d'une virtualisation au niveau du matériel, et Windows l'utilise habilement.

 
Alexey Volchanskiy:

Quel conte de fées, cela n'était possible que dans Windows 3.*. Windows ne vous laissera pas accéder à la mémoire de quelqu'un d'autre, chaque processus travaille dans sa propre zone, et pour lui l'adressage de la mémoire commence à zéro, c'est ainsi qu'il est présenté par Windows. Et en général, Windows n'alloue de la mémoire que lorsqu'il écrit réellement des données. Faites un tableau double arr[1024*1024*1024] et voyez combien de mémoire est réellement allouée dans le Gestionnaire des tâches. Mais pas du tout ! Tant que vous ne commencerez pas à écrire dans le tableau, la mémoire ne sera pas allouée par tranches de 4Kb. Même si vous l'écrivez en utilisant des indices aléatoires, il sera toujours dans de tels morceaux. Comment Windows virtualise tout cela me paraît insondable !

Défaut de page. L'exception était un coup de massue - ils donnaient de la mémoire par page, rien de plus. C'est pratique et transparent pour les applications, mais cela entraîne une fragmentation de la mémoire. Vous pouvez allouer de la mémoire physique d'un seul coup si vous appelez virtuallock sur le pointeur résultant après virtualalloc. Au fait, c'est un trou intéressant, je vais devoir voir s'il est possible de faire planter le serveur de cette façon.


Trois n'avait pas la virtualisation, c'est un système différent, pas NT. Il y avait beaucoup de queue de DOS là-dedans, la moitié des fonctions du système dépendaient de l'int 21.

 

Ce cas n'est pas clair :

/*
 * The mine_score structure describes the maximum normalized mutual information
 * scores (i.e. the characteristic matrix if est=EST_MIC_APPROX, the
 * equicharacteristic matrix instead). M[i][j] contains the score using a grid
 * partitioning x-values into i+2 bins and y-values into j+2 bins. m and M are
 * of length n and each M[i] is of length m[i].
 */
typedef struct mine_score
{
  int n;      /* number of rows of M */
  int *m;     /* number of cols of M[i] for each i */
  double **M; /* the (equi)characteristic matrix */
} mine_score;

En outre, dans le f-i, la taille de la matrice M est modifiée :

/*
 * Returns an initialized mine_score structure. Returns NULL if an error
 * occurs.
 */
 mine_score *init_score(mine_problem *prob, mine_parameter *param)
{
  int i, j;
  double B;
  mine_score *score;

  if ((param->alpha > 0.0) && (param->alpha <= 1.0))
    B = MAX(pow(prob->n, param->alpha), 4);
  else if (param->alpha >= 4)
    B = MIN(param->alpha, prob->n);
  else
    goto error_score;

  score = (mine_score *) malloc (sizeof(mine_score));
  if (score == NULL)
    goto error_score;

  score->n = MAX((int) floor(B/2.0), 2) - 1; задали кол-во строк, ок
  score->m = (int *) malloc(score->n * sizeof(int)); а кол-во столбцов тут чему равно? кол-ву строк?
  if (score->m == NULL)
    goto error_score_m;

  for (i=0; i<score->n; i++)
    score->m[i] = (int) floor((double) B / (double) (i+2)) - 1;

  score->M = (double **) malloc (score->n * sizeof(double *));
  if (score->M == NULL)
    goto error_score_M;

  for (i=0; i<score->n; i++)
    {
      score->M[i] = (double *) malloc ((score->m[i]) * sizeof(double)); а здесь идет просто выделение памяти для матриы М?
      if (score->M[i] == NULL)
        {
          for (j=0; j<i; j++)
            free(score->M[j]);
          goto error_score_M_i;
        }
    }

  return score;

  error_score_M_i:
    free(score->M);
  error_score_M:
    free(score->m);
  error_score_m:
    free(score);
  error_score:
    return NULL;
}

Autrement dit, si je comprends bien, tout ce bazar ne sert qu'à allouer de la mémoire pour la matrice, mais celle-ci n'est remplie d'aucune valeur ? Donc, ce code peut être jeté pour mql (enfin, après avoir déterminé le nombre de lignes et le même nombre de colonnes de la matrice carrée)

ou la matrice est initialisée avec des valeurs

 
Alexey Volchanskiy:

...Comment le système éolien virtualise tout cela est insondable pour moi !

Lis Richter. Il a tout mâché au point de te faire mal au cœur.

SeriousRacoon:
Au fait, c'est un trou intéressant, je vais devoir voir s'il est possible de faire planter le serveur de cette façon.

Tu ne peux pas.

 
Maxim Dmitrievsky:

Ce cas n'est pas clair :

typedef struct mine_score
{
  int n;      /* number of rows of M */
  int *m;     /* number of cols of M[i] for each i */
  double **M; /* the (equi)characteristic matrix */
} mine_score;
  score->n = MAX((int) floor(B/2.0), 2) - 1; задали кол-во строк, ок
  score->m = (int *) malloc(score->n * sizeof(int)); а кол-во столбцов тут чему равно? кол-ву строк?
score->M[i] = (double *) malloc ((score->m[i]) * sizeof(double)); а здесь идет просто выделение памяти для матриы М?

De plus, il y a un changement dans la taille de la matrice M dans le f-i :

Autrement dit, si je comprends bien, tout ce bazar ne sert qu'à allouer de la mémoire pour la matrice, mais celle-ci n'est remplie d'aucune valeur ? Donc, ce code peut être jeté pour mql (enfin, après avoir déterminé le nombre de lignes et le même nombre de colonnes de la matrice carrée)

ou, après tout, la matrice est initialisée avec des valeurs

Dansmine_score*m est un pointeur vers int, et le commentaire dit que c'est un tableau, donc chaque ligne a un nombre différent de colonnes, c'est appelé un "tableau en peigne" pas rectangulaire.

score->m = (int *) malloc(score->n * sizeof(int))

Il alloue simplement de la mémoire pour ce tableau de longueurs de lignes, sans aucune valeur.

Pour la matrice M elle-même.

score->M = (double **) malloc (score->n * sizeof(double *));

ici est allouée la mémoire pour les pointeurs des lignes

score->M[i] = (double *) malloc ((score->m[i]) * sizeof(double)); а здесь идет просто выделение памяти для матриы М?

et ici pour les colonnes

1234567891011
Nouveau commentaire