Ejecución segu a y con limi ación de
memo ia de p og amas en Py hon
T abajo de Fin de G ado
Da id Sa nago Ojuel
G ado en Ingenie ía In o má ica
Facul ad de In o má ica
Uni e sidad Complu ense de Mad id
Junio 2021
Documen o maque ado con T
EXiS .1.0.
Es e documen o es á p epa ado pa a se imp imido a doble ca a.
Ejecución segu a y con limi ación de
memo ia de p og amas en Py hon
Sa e and memo y-limi ed execu ion o Py hon
p og ams
Memo ia que p esen a pa a op a al í ulo de G ado en Ingenie ía
In o má ica
Di igido po
Ma co An onio Gómez Ma ín
Ped o Pablo Gómez Ma ín
G ado en Ingenie ía In o má ica
Facul ad de In o má ica
Uni e sidad Complu ense de Mad id
Junio 2021
Copy igh ©Da id Sa nago Ojuel
Resumen
Los jueces en línea, como po ejemplo ¡Acep a el Re o!1(Gómez-Ma ín
y Gómez-Ma ín, 2017), eciben p og amas en iados po los usua ios y los
ejecu an pa a comp oba su co ección. Es a ejecución debe se ealizada
bajo un en o no segu o, que no ponga en iesgo la máquina del juez, y bajo
una es icción de memo ia impues a po cada p oblema.
Desa olla un sis ema de ejecución segu o con limi ación de memo ia
pa a p og amas en Py hon es á, como el í ulo indica, o mado po dos pun os
undamen ales.
La limi ación de memo ia de un p og ama pe mi e al en o no es ingi
el uso o al que es e puede hace ejecu ándose en su in e io . El obje i o
no solo es e i a pone en iesgo el mismo en o no debido al al o uso de
memo ia, sino el de implemen a una limi ación mucho más es ic i a pa a
los p og amas que pe mi a, po ejemplo, disc imina soluciones con consumo
lineal de memo ia.
La ejecución segu a pe mi e al en o no ejecu a cualquie ipo de p og a-
ma sin eme po la in eg idad de la máquina que lo es á ejecu ando. Es o
se puede consegui es ingiendo las unciones que se pueden emplea den o
de un p og ama o ealizando su ejecución en un en o no que po sí mismo
no pe mi a la ejecución de cie as unciones.
Es e abajo consis e en un es udio e implemen ación de di e en es o mas
de aba ca los dos pun os an e io es y uni los en un solo p og ama, capaz
de ejecu a cualquie ipo de código Py hon de o ma segu a y con una
limi ación sob e la memo ia máxima que puede u iliza .
Palab as cla e:Py hon, ejecución segu a, limi ación de memo ia, ¡Acep-
a el Re o!,Linux,ch oo , juez en línea, llamadas al sis ema.
1h ps://acep ael e o.com/

Abs ac
Online judges like ¡Acep a el Re o!1(Gómez-Ma ín y Gómez-Ma ín,
2017) ecei e small p og ams submi ed by he use s and un hem o check
hei co ec ness. This execu ion mus be ca ied ou in a sa e en i onmen ,
which does no pu he judge’s machine a isk, and unde memo y es ic ion
imposed by each p oblem.
De eloping a memo y-limi ed secu e execu ion sys em o Py hon is, as
he i le says, made up o wo essen ial poin s.
Limi ing he memo y o a p og am allows he en i onmen o es ic he
maximum memo y ha can be used by hem inside i . The goal is no only
o a oid pu ing he en i onmen a isk due o high memo y usage, bu o
implemen a mo e es ic i e limi a ion o he p og ams o disc imina e, o
example, solu ions wi h linea memo y consump ion.
Sa e execu ion allows he en i onmen o un any kind o p og am wi hou
wo ying abou he in eg i y o he machine ha is unning i . This can be
achie ed by es ic ing he unc ions ha can be used in he p og ams o
by unning hem inside an en i onmen ha doesn’ allow he execu ion o
hose unc ions by de aul .
Es e abajo consis e en un es udio de las di e en es o mas de aba ca
los dos pun os an e io es y uni los en un solo p og ama, capaz de ejecu a
cualquie ipo de código Py hon de o ma segu a y con una limi ación sob e
la memo ia máxima que puede u iliza .
This wo k consis s hen on a s udy and implemen a ion o he di e en
ways o dealing wi h he las wo poin s and combining hem on a single
p og am, capable o execu ing any kind o Py hon code sa ely and memo y-
limi ed.
Keywo ds:Py hon, sa e execu ion, memo y-limi ed, ¡Acep a el Re o!,
Linux,ch oo , online judges, sys em calls.
1h ps://acep ael e o.com/
ii
Índice
Resumen
1. In oducción 1
1.1. Obje i os ............................. 1
1.2. Plande abajo.......................... 2
1.3. Es uc u a de la memo ia . . . . . . . . . . . . . . . . . . . . 3
2. Es ado del a e 9
2.1. P og amación compe i i a . . . . . . . . . . . . . . . . . . . . 9
2.2. Juecesenlínea .......................... 10
2.3. Py hon como lenguaje de p og amación compe i i a . . . . . 11
2.4. Jueces au omá icos que sopo an Py hon . . . . . . . . . . . . 12
2.5. Implemen ación de Py hon .................... 13
2.6. Tamaño de los da os en memo ia . . . . . . . . . . . . . . . . 14
2.6.1. Lib e ía es ánda de Py hon . . . . . . . . . . . . . . . 14
2.6.2. Módulos ex e nos . . . . . . . . . . . . . . . . . . . . . 16
2.7. Medición del consumo . . . . . . . . . . . . . . . . . . . . . . 17
2.8. Limi ación del consumo de memo ia . . . . . . . . . . . . . . 21
3. Ejecución Segu a 25
3.1. Res icción de llamadas al sis ema . . . . . . . . . . . . . . . 25
3.2. Llamadas al sis ema ealizadas po un p og ama . . . . . . . 26
3.2.1. Bloquea llamadas al sis ema . . . . . . . . . . . . . . 27
3.2.2. Llamadas a pe mi i en Py hon . . . . . . . . . . . . . 28
3.2.3. Implemen ación . . . . . . . . . . . . . . . . . . . . . . 30
3.3. Ejecución segu a median e ch oo ................ 34
3.3.1. Ejecu a Py hon den o de ch oo ............ 35
4. Limi ación de Memo ia 39
4.1. Medición de memo ia . . . . . . . . . . . . . . . . . . . . . . . 39
4.2. Limi ación de memo ia . . . . . . . . . . . . . . . . . . . . . . 41
4.3. Uso de memo ia de Py hon . . . . . . . . . . . . . . . . . . . 44
ix
6Capí ulo 1. In oducción
De elop he inal en i onmen combining he chosen me hods o memo y-
limi ing and secu i y.
Valida e he en i onmen by unning a se o p oblems on i and e a-
lua ing he esul s ob ained.
Wo k plan
This p ojec will begin wi h a gene al in es iga ion o he language i sel ,
Py hon, memo y limi a ion and sa e execu ion.
We will conduc a small s udy on he iabili y o Py hon as a language
in compe i i e p og amming. Di e en online judges ha allow he use o
Py hon will be in es iga ed, ob aining he esul s o hose use s who used
Py hon as hei main language.
We will in es iga e he memo y usage o di e en objec s and s uc u-
es o he language, coding small p og ams ha show us hei sizes, using
bo h Py hon s anda d lib a y and ex e nal modules. This phase will be con-
duc ed in o de o amilia ize ou sel es wi h he in e nal mechanisms o he
language.
The nex s ep will p obably be o measu e he maximum memo y used
by a p og am h oughou i s execu ion and o decide which ools will be used
o he implemen a ion. Then we epea his p ocess, his ime o igu e ou
how o limi he maximum memo y usable by a p og am du ing i s execu ion.
Then, documen a ion abou sa e execu ion will begin, ob aining a so-
me mechanisms o he implemen a ion, which will ce ainly need ano he
in es iga ion phase.
Once we ha e he las wo poin s in o de , we will ha e o combine bo h
in o a single one in cha ge o he execu ion o Py hon p og ams as old wi h
limi a ions in bo h ime and memo y, all o his in a sa e en i onmen .
Finally, wi h he execu ion sys em ully de eloped and wo king, a alida-
ion phase will be conduc ed in o de o e alua e ha i mee s he obje i es.
Memo y s uc u e
This memo y is s uc u ed in 7 chap e s:
In his i s one, we p esen he p oblem o which we wan o de elop
a solu ion, as well as his plan ollowed o achie e i .
In he second chap e we e lec he majo i y o he knowledge acqui ed
du ing he esea ch phase. In addi ion, some o he mechanisms and
ools ha will be used in he nex chap e s a e in oduced.

1.3. Es uc u a de la memo ia 7
In he hi d one, we show he me hods used o secu e he execu ion
sys em, wi h an in oduc ion we e hey a e explained, an analysis o
i s needs o be applied speci ically o Py hon and an implemen a ion.
The ou h chap e goes in o g ea dep h on some aspec s explo ed
in he second ega ding memo y limi a ion, as well as he inal imple-
men a ion o he en i onmen . Also, a s udy o he iabili y o he
language is ca ied ou o he sol ing o memo y-limi ed p oblems.
The i h chap e shows he inal implemen a ion, which combines e e y-
hing de eloped in he p e ious wo chap e s. I p esen s he cha ac-
e is ics o he execu ion sys em and some es s pe o med on i .
In he six h one we es he capabili ies o he en i onmen pe o ming
a alida ion phase.
And inally, in he se en h chap e we end his documen wi h some
gene al conclusions abou he inal en i onmen , i s sho comings and
i s s eng hs.
Capí ulo 2
Es ado del a e
Py hon es un lenguaje de p og amación so p enden emen e an iguo (la
e sión 1.0 ue lanzada en 1991, 5 años an es que Ja a 1.0) cuya popula idad
ha su ido una explosión en los úl imos años debido a su simpleza, acilidad
de uso, e sa ilidad y po encia. Es a popula idad ha sido p opulsada en g an
pa e po su g an a iedad de lib e ías (Numpy,Tenso low,Sciki ,Pandas,
e c) que lo han hecho el lenguaje po de ec o del análisis de da os.
2.1. P og amación compe i i a
La p og amación compe i i a es un depo e en el que los pa icipan es
in en an esol e el mayo núme o de p oblemas en el meno iempo posible.
La esolución de los p oblemas equie e la codi icación de un p og ama aco de
a sus ca ac e ís icas.
Po lo gene al, los p oblemas son de na u aleza ma emá ica o lógica y
equie en conocimien os de di e sos campos como: combina o ia, eo ía de
núme os, eo ía de g a os, es uc u as de da os, algo i mia, e c.
Independien emen e del ipo de p oblema, el p oceso de esolución se
puede di idi en dos pasos: la cons ucción de un algo i mo e icien e que
esuel a el p oblema, y la implemen ación de es e en un lenguaje de p og a-
mación. La e aluación de la co ección de los p og amas se ealiza de o ma
au omá ica en los llamados jueces en línea, que e emos en la siguien e sec-
ción.
Cada p oblema, gene almen e, es á o mado po a ias pa es:
Nomb e y lími es: el í ulo del p oblema, que puede o no da pis as
sob e su esolución, y los lími es que se es ablecen en la ejecución de
es e, iempo y memo ia.
Desc ipción del p oblema: donde se nos plan ea el p oblema que e-
nemos que esol e . Las desc ipciones de los p oblemas a ían, desde
9
10 Capí ulo 2. Es ado del a e
aquellas que nos indican di ec amen e la esolución del p oblema, has a
las que lo ocul an lo máximo posible.
Desc ipción de la en ada y la salida: la p ime a nos indica el o ma o
que sigue la en ada, así como los lími es que debemos espe a pa a los
pa áme os del p oblema. Es o úl imo es especialmen e ele an e en
la cons ucción del algo i mo, po que la magni ud de cada pa áme o
nos da pis as sob e cómo debemos esol e lo (si el p oblema equie e
o dena y nos dicen que espe emos has a 1 millón de elemen os, no po-
demos esol e lo con un algo i mo cuad á ico, ya que amos a ob ene
TLE). La desc ipción de la salida nos dice cómo espe a el juez que es a
es é o ma eada. Dado que la comp obación se hace au omá icamen e,
debemos se cuidadosos de segui la exac amen e, u ob end emos un
e edic o inco ec o.
Ejemplos de en ada y salida: en es as secciones se mues a una en ada
y salida de ejemplo, siguien e las desc ipciones dadas. Es as si en pa a
comp oba la co ección del p og ama una ez ha sido codi icado.
2.2. Jueces en línea
Los jueces en línea son sis emas en línea que gene almen e con ienen un
eposi o io de p oblemas a esol e y un sis ema de e aluación de p og a-
mas. Sob e ellos, los usua ios pueden en ia sus soluciones a los di e en es
p oblemas y ob ene un e edic o sob e su co ección. El sis ema compila el
código en iado (en caso de a a se de un lenguaje compilado) y lo ejecu a
con una se ie de casos sec e os a los cuales el usua io no iene acceso. Las
salidas del p og ama en iado son compa adas con las co ec as y en base a
ello el juez dic a el e edic o.
No solo se comp ueba la co ección de los p og amas, sino ambién que
es os consiguen la espues a en un iempo de ejecución y uso de memo ia
máxima limi ado.
Los posibles e edic os a ían con cada juez, aunque los más habi uales
son:
Acep ado (AC): la salida del p og ama coincide con la espe ada.
Respues a inco ec a (WA): la salida no coincide con la espe ada.
Lími e de iempo excedido (TLE): el p og ama ha a dado demasiado
iempo en inaliza y se ha e minado su ejecución.
Lími e de memo ia excedido (MLE): el p og ama ha u ilizado más me-
mo ia de la pe mi ida y se ha e minado su ejecución.
E o de ejecución (RTE): el p og ama ha allado du an e la ejecución.
2.3. Py hon como lenguaje de p og amación compe i i a 11
E o de compilación (CE): el p og ama en iado no ha podido se
compilado.
En la ac ualidad exis en mul i ud de jueces en línea, como el ya mencio-
nado ¡Acep a el Re o!,Code o ces1,onlinejudge2y muchos o os que comen-
a emos más adelan e.
2.3. Py hon como lenguaje de p og amación com-
pe i i a
La popula idad de Py hon en o os e enos no se ha is o e lejada en
la p og amación compe i i a y en los jueces au omá icos, donde Py hon es
un lenguaje de nicho, muchas eces incapaz de esol e p oblemas po al a
de elocidad.
Code o ces es uno de los jueces au omá icos más popula es de la ac ua-
lidad. No solo es un juez, sino que ambién o ganiza mul i ud de concu sos
de p og amación online. Los esul ados de los usua ios en es os concu sos
(sepa ados en di isiones en base a su di icul ad) de e minan su a ing, en un
sis ema simila al Elo3(Elo, 1978). Dependiendo del a ing, los usua ios son
clasi icados en di e en es ca ego ías(Looi, 2018).
Conc e amen e, aquellos con un a ing mayo a 2400 (la ca ego ía G and-
mas e y supe io es), o man el 0.3 % de los usua ios de la página y son co-
nocidos como Reds. Un análisis ealizado po uno de los usua ios en 20174
e leja cómo de los 278 Reds que había en ese momen o en el juez, solo 3 de
ellos han llegado a u iliza Py hon en algún momen o. Además ecalca que
ninguno lo u iliza como su lenguaje p incipal.
Vemos algo simila en el juez de la Uni e sidad de Valladolid, UVa Judge
(ac ualmen e onlinejudge)(Re illa e al., 2008). El sopo e pa a en íos en
Py hon ue añadido en 2016, año en el que u o 27.633 en íos (1.45 % del
año). Desde en onces, ese po cen aje ha ido aumen ando cada año, has a el
5.49 % en lo que lle amos de 20215.
A pesa de es e aumen o del uso de Py hon, si analizamos es os en íos
y los ag upamos po p oblemas, podemos comp oba como de los casi 5000
p oblemas disponibles en el juez, al ededo de 2700 de ellos no ienen ningún
en ío en Py hon co ec o (Ve edic o AC). Algunos de es os p oblemas, como
el 929 - “Numbe Maze”6con 248 en íos con e edic o lími e de iempo
(TLE), p obablemen e sean imposibles de esol e en el iempo es ablecido.
1h ps://code o ces.com/
2h ps://onlinejudge.o g/
3h ps://en.wikipedia.o g/wiki/Elo_ a ing_sys em
4h ps://code o ces.com/blog/en y/55177
5h ps://web.a chi e.o g/web/20210303221028/h ps://onlinejudge.o g/
index.php?op ion=com_onlinejudge&I emid=23
6h ps://onlinejudge.o g/ex e nal/9/929.pd

12 Capí ulo 2. Es ado del a e
2.4. Jueces au omá icos que sopo an Py hon
Como hemos comen ado, muchos jueces au omá icos sopo an el uso de
Py hon, en e los ya mencionados enemos a UVa judge yCode o ces, además
de o os como Ka is1,SPOJ2,Codeche 3,Hacke ank4,Hacke ea h5,URI
Online Judge6, e c.
En odos ellos, el lenguaje su e las mismas des en ajas comen adas en
la sección an e io , donde su al a de elocidad hace su uso subóp imo en e
a o os lenguajes. Algunos de es os jueces in en an con a es a es a des-
en aja es ableciendo un lími e de iempo di e en e pa a cada lenguaje. Po
ejemplo, URI Online Judge es ablece un iempo lími e base pa a C/C++ y
a es e se le añade iempo según el lenguaje (a Py hon se le añade 1 segun-
do). También enemos a Codeche yHacke ea h, donde en ez de suma ,
los di e en es lenguajes ienen un mul iplicado de iempo sob e el base.
Pasando del iempo a la memo ia, ninguno de es os jueces hace una
limi ación sob e el uso de memo ia an es ic i o como lo hace ¡Acep a el
Re o! en los lenguajes que sopo a, op ando la mayo ía po una limi ación
global sob e odos los p oblemas que debe ía se su icien e pa a cualquie
ipo de p oblema. En Ka is po ejemplo, la mayo ía de p oblemas ienen
1024 MB, po lo que el e edic o MLE es á más como p o ección al juez que
como limi ación de los p oblemas. Si lo compa amos con ¡Acep a el Re o!,
enemos unos lími es de memo ia mucho más a iados y ajus ados, como
podemos obse a en la siguien e abla:
Lími e (MiB) 2 4 8 10 12 16 20 24 32 48 64 96 128
NºP oblemas 7 399 49 17 1 22 4 1 8 1 4 1 1
Vemos que la g an mayo ía ienen un lími e de 4 MiB, con los siguien es
alo es po núme o de p oblemas de 8, 16 y 10 MiB. A pesa de es os lími es
mucho más es ic i os, g an pa e de ellos no es án limi ados pa a aumen a
la di icul ad del p oblema, sino que en su mayo ía se les asigna una can idad
adecuada a su esolución. Si un p oblema equie e lee un núme o y esc ibi
su cuad ado no amos a pe mi i que use 128 MiB.
En con as e, enemos p oblemas donde casi el 30 % de los en íos esul an
en MLE (189 - “Emba que en un ansa lán ico” y 248 - “Los p emios de las
agape as”) con lími es de memo ia de 8 MiB y 2 MiB espec i amen e. En
es e caso la es icción de memo ia sí que hace su esolución de es e ipo de
p oblemas más compleja, añadiendo p o undidad y a iedad a los ipos de
p oblemas o ecidos.
1h ps://open.ka is.com
2h ps://www.spoj.com/
3h ps://www.codeche .com/
4h ps://www.hacke ank.com/
5h ps://www.hacke ea h.com/
6h ps://www.u ionlinejudge.com.b /
2.5. Implemen ación de Py hon 13
Cambiando de jueces en línea a so wa e pa a ges ión de concu sos, DOM-
judge1es un juez diseñado especí icamen e pa a el desa ollo de concu sos de
p og amación compe i i a. Tiene sopo e pa a Py hon y es código abie o,
hos eado en gi hub2. G acias a es o, podemos e exac amen e cómo maneja
la ejecución segu a de los p og amas en Py hon y e de qué o ma limi a su
uso de memo ia. Siendo más especí icos, la limi ación que impone es e juez
es la misma que e emos en la sección 2.8.
2.5. Implemen ación de Py hon
Po lo gene al, siemp e que se habla de Py hon se hace en e e encia a la
implemen ación es ánda del mismo, CPy hon( an Rossum, 2010). Es a es
la implemen ación de e e encia del lenguaje y po mucho la más u ilizada.
A lo la go de es e p oyec o, odas las peculia idades que hemos is o y que
e emos son ace ca de es a implemen ación.
La implemen ación CPy hon consis e en un in é p e e del lenguaje esc i o
en C. An es de in e p e a lo, el código Py hon es compilado a by ecode( an
Rossum, 2010), el cuál sí es in e p e ado.
Sin emba go, CPy hon no es la única implemen ación de Py hon exis en-
e. Tenemos una implemen ación esc i a en Ja a pa a su máquina i ual,
Jy hon3(Juneau e al., 2010); una implemen ación en C#,I onPy hon4(Foo d
y Mui head, 2009); y una e sión esc i a en el p opio Py hon,PyPy5(Bolz e
al., 2009). Es es a úl ima en la que nos amos a cen a en es e apa ado.
En con as e a la in e p e ación del código en CPy hon,PyPy u iliza
una compilación en iempo de ejecución, JIT ojus -in- ime, en donde el
código ob enido en la compilación, by ecode, es aducido a código máquina
du an e la p opia ejecución. Es e cambio hace que, po lo gene al, PyPy sea
conside ablemen e más ápido que CPy hon(Roghul , 2016). Es a elocidad
es p opo cionada a cambio de una meno compa ibilidad con algunas lib e ías
muy usadas del lenguaje, lo que hace que es a implemen ación al e na i a
no enga un uso más ecuen e6.
Es o po el con a io no a ec a en absolu o a la p og amación compe i i a,
pues esas lib e ías no se usan en los concu sos. Es po es o en g an pa e de los
jueces en línea PyPy sea la implemen ación u ilizada pa a ejecu a código en
Py hon. Po ejemplo, el juez Ka is u iliza PyPy3,Code o ces o ece PyPy2
yPyPy3, al igual que Hacke ank. En es e úl imo, ambos PyPy2 yPyPy3
ienen un iempo lími e de 4 segundos, en e a las 10 impues os en las
1h ps://www.domjudge.o g/
2h ps://gi hub.com/DOMjudge/domjudge
3h ps://www.jy hon.o g/
4h ps://i onpy hon.ne /
5h ps://www.pypy.o g/index.h ml
6h ps://doc.pypy.o g/en/la es /cpy hon_di e ences.h ml#
ex ension-modules
14 Capí ulo 2. Es ado del a e
e siones de CPy hon, lo que mues a la supe io elocidad espe ada de es a
implemen ación.
Po es as azones se ha op ado po , al menos, que el sis ema de ejecución
que se desa olle en es e p oyec o cuen e con la opción de elegi lib emen e
la implemen ación de Py hon que ejecu a á los p og amas indicados.
2.6. Tamaño de los da os en memo ia
El uso de memo ia de Py hon es una de las pa es del lenguaje que menos
a ención ha enido. A pesa de es a al a de es udio, enemos a nues a
disposición di e en es he amien as pa a la medición de la memo ia usada
po un p oceso Py hon.
2.6.1. Lib e ía es ánda de Py hon
An es de medi la memo ia o al usada po el p oceso, amos a explo a
las opciones que nos o ece la lib e ía es ánda en espec o al uso de memo ia.
En p ime luga hemos in es igado la unción ge sizeo del módulo sys.
Es a unción acep a como pa áme o cualquie obje o Py hon y nos de uel e
su amaño en by es. En las siguien es abla se mues an los amaños de los
ipos de da os p imi i os y es uc u as es ánda acías:
Obje o in (0) in (1) in (10^100) loa (0) loa (1) loa (10^100)
Tamaño (by es) 24 28 72 24 24 24
Lo p ime o que nos encon amos es que el amaño de lo que conocemos
en o os lenguajes como in o en e os, empieza en 24 by es. Es o es debido
a que en Py hon odos los núme os es án implemen ados como una clase
de núme os de p ecisión in ini a, con un pun e o de 8 by es a la clase, un
con ado de e e encia ambién de 8 by es, y el es o la ep esen ación del
núme o. En es a, cada núme o es a o mado po un a ay de en e os de 32
bi s, cada uno ep esen ando 30 dígi os bina ios del núme o comple o. No
obs an e, en algunas implemen aciones (Van Rossum e al., 2000), se u ilizan
unsigned sho de 16 bi s que ep esen an 15 dígi os bina ios cada uno.
El ce o en pa icula es á ep esen ado po un a ay acío, lo que hace
que ocupe 4 by es (32 bi s) menos que el 1. De es a o ma, los núme os en e
el 1 y el 230
−1ocupa án 28 by es, los que es én en e el 230 y260
−1
ocupa án 32, e c.
Al inal de la abla enemos los núme os eales, en Py hon, loa . Vemos
de nue o como el 0 uel e a ocupa 24 by es y que, al con a io que en los
en e os, odos ocupan lo mismo. Es o es debido a que la clase loa es á
implemen ada usando núme os en pun o lo an e de doble p ecisión, de 8
by es y que al con a io de los en e os, es os no ienen p ecisión in ini a.
2.6. Tamaño de los da os en memo ia 15
Obje o bool(False) bool(T ue) s (“”) s (“a”) s (“abcde”)
Tamaño (by es) 28 24 49 50 54
Lo único des acable en los bool es que el espacio que ocupan T ue yFalse
di ie e, aunque podemos en ende es a di e encia ápidamen e si sabemos
que bool es una subclase de in , con False siendo 0 y T ue siendo cualquie
o o alo .
En el úl imo ipo p imi i o, enemos las cadenas de ca ac e es, el ipo
s ing. En es e caso, la cadena acía ocupa un o al de 49 by es, mien as
que cada ca ác e ex a añade 1 by e a es e alo .
Me ece la pena menciona que Py hon u iliza la ep esen ación Unico-
de1(Van Rossum e al., 2000). Como es e con iene ac ualmen e 143,859 ca-
ac e es, es necesa io un mínimo de 18 dígi os bina ios pa a ep esen a cada
uno de ellos, que po é minos de endimien o y alineamien o se suelen co-
di ica con 4 by es. Pa a educi el consumo de memo ia, Py hon u iliza 3
ep esen aciones de cadenas di e en es según los ca ac e es que es én con e-
nidos en el s ing:
1 by e po ca ac e : La in-1 encoding, una codi icación o mada po
ASCII y 128 ca ac e es ex a de di e en es lenguajes (como po ejemplo
la Ñ). Es el caso desc i o en la abla an e io .
2 by es po ca ac e : UCS-2 encoding, con iene casi la o alidad de los
ca ac e es usados en el es o de lenguajes. En es e caso, la cadena acía
ocupa 74 by es.
4 by es po ca ac e : UCS-4 encoding, que con iene la o alidad de
Unicode. U ilizado po ejemplo pa a emojis. La cadena acía en es a
ep esen ación ocupa un o al de 76 by es.
Obje o lis () lis ([1]) lis ([1, 2]) dic () dic ({1: 1})
Tamaño (by es) 56 64 72 232 232
Vemos que la lis a acía ocupa 56 by es. A con inuación enemos la lis a
que con iene 1 elemen o, con un amaño de 64 by es. Si eco damos de la
p ime a abla, el en e o 1ocupa un o al de 28 by es. De la misma o ma,
enemos que eco da que los ipos en Py hon son ins ancias de clases, po
lo que llegamos a la conclusión de que la lis a no gua da los elemen os en sí,
sino pun e os a es as clases (en Py hon odos los pun e os ocupan 8 by es).
Algo simila ocu e en el caso de los dicciona ios. El acío ocupa 232
by es, la misma can idad que un dicciona io con un elemen o. Es o es debido
a que la unción ge sizeo únicamen e iene en cuen a la memo ia usada
1h ps://home.unicode.o g/
22 Capí ulo 2. Es ado del a e
Peak memo y (MiB): 47.01
Peak memo y (MiB): 54.63
Peak memo y (MiB): 54.63
Como se puede obse a , an o la p ime a como la segunda consul a son
muy simila es a los módulos u ilizados en la sección an e io . Po el con a io,
en la e ce a consul a, la de la lis a que no ocupa amaño po es a en la
caché de en e os, emos que la memo ia u ilizada asciende en unos 8 MiB.
Es e aumen o de memo ia es debido a que el ecolec o de basu a no ac úa
cuando la lis a es eesc i a, sino que simplemen e se le asigna una nue a
di ección y se e iene en memo ia. La úl ima lec u a es ealizada después de
asigna la lis a la una lis a acía, que ya hemos comp obado que hace ac ua
al ecolec o y aún así man enemos la misma memo ia que en la an e io ,
espe able eniendo en cuen a que es amos midiendo el pico de memo ia, no
la que ac ualmen e eside en memo ia.
Si en ez de easigna la lis a, hubié amos asignado la lis a a una acía
l = []
ob end íamos los siguien es esul ados:
$ py hon maxMemo y.py
Peak memo y (MiB): 8.20
Peak memo y (MiB): 46.98
Peak memo y (MiB): 46.98
Peak memo y (MiB): 46.98
Es a ez, el ecolec o de basu a ha ac uado, po lo que la memo ia de la
e ce a lec u a es la misma que la segunda. Reco demos que, en con as e a
las mediciones ob enidas con los módulos an e io es, en es a ocasión es amos
ob eniendo la máxima memo ia usada, po lo que ob ene la misma medida
es co ec o.
Pa a la pa e de limi a la máxima memo ia u ilizable po un p oceso,
enemos la llamada al sis ema se limi (Mi chell e al., 2001). En es e caso,
a la unción le enemos que indica que ecu so que emos limi a y la can idad
usando una es uc u a limi . El ecu so a limi a es la memo ia usada
po los da os del p og ama (sin con a la inicialización), co espondien e
al ecu so RLIMIT_DATA. La siguien e unción u iliza es a llamada pa a
limi a la memo ia del p oceso ac ual a la can idad indicada po limi en
MiB:
de limi _memo y(limi ):
s c = esou ce.RLIMIT_DATA
so , ha d = esou ce.ge limi ( s c)
esou ce.se limi ( s c, (limi * 1024**2, ha d))
e u n
limi _memo y(50)

2.8. Limi ación del consumo de memo ia 23
Si ejecu amos con las lis as de siemp e, que hemos is o que ocupan un
máximo de 47 MiB, podemos espe a que e mine con no malidad:
$ py hon limi Memo y.py
Peak memo y (MiB): 7.99
Peak memo y (MiB): 46.93
Peak memo y (MiB): 46.93
mien as que si limi amos la memo ia máxima a 40 MiB, lo espe able es
que el p oceso sea in e umpido po el sis ema ope a i o:
$ py hon limi Memo y.py
Peak memo y (MiB): 8.07
T aceback (mos ecen call las ):
File "/media/s _TFG/T abajoAc ual/limi Memo y.py", line 26, in <module>
l = [ge X(-10) o a in ange(1000000)]
File "/media/s _TFG/T abajoAc ual/limi Memo y.py", line 26, in <lis comp>
l = [ge X(-10) o a in ange(1000000)]
Memo yE o
Con es as dos úl imas unciones, ge usage yse limi , con amos con
las he amien as necesa ias pa a desa olla la pa e de medición y limi ación
de memo ia del en o no de ejecución de p og amas en Py hon.
Capí ulo 3
Ejecución Segu a
Se capaz de ejecu a cualquie ipo de p og ama sin ene que p eocu-
pa se po in enciones maliciosas de sus usua ios es posiblemen e la pa e más
impo an e del ejecu o de un juez en línea.
Pa a consegui lo, debemos asegu a nos que nues o en o no es lo su i-
cien emen e e sá il como pa a pe mi i la ejecución de aquellos p og amas
que cumplan con la no ma i a es ablecida en el juez, y lo su icien emen e
obus o como pa a no e se a ec ado, de ec a y ac ua en consecuencia an e
cualquie código que conside emos malin encionado.
En es e capí ulo abo da emos la a ea de p o ege el en o no de ejecución
an e odo ipo de código en iado po los usua ios.
3.1. Res icción de llamadas al sis ema
El p ime mecanismo que amos a u iliza pa a la p o ección del en o no
es el bloqueo de llamadas al sis ema. Reco demos, que la pla a o ma obje i o
de es e p oyec o es un en o no Linux y que la cons ucción de un en o no
de ejecución segu a es comple amen e dependien e de la pla a o ma donde
se ejecu a á.
Una llamada al sis ema es un mé odo o unción que puede in oca
un p oceso pa a solici a un cie o se icio al sis ema ope a i o.
Las llamadas al sis ema en Linux son el mecanismo po el cuál el usua io
se comunica con el núcleo (o ke nel) del sis ema ope a i o. En e muchas
o as, ead yw i e son llamadas al sis ema que en es e caso nos pe mi en
lee y esc ibi en iche os abie os (po o a llamada al sis ema, open). La
lis a comple a de llamadas al sis ema se encuen a en la segunda sección del
manual de Linux1.
1h ps://man7.o g/linux/man-pages/di _sec ion_2.h ml
25
26 Capí ulo 3. Ejecución Segu a
Resul a ácil e el cómo, si bloqueamos po ejemplo la llamada al sis ema
open, cualquie in en o de ab i un iche o se á in e umpido po el sis ema
ope a i o. Con es a misma iloso ía, amos a aden a nos en el mundo de la
de ección e in e upción de llamadas al sis ema.
Pa a log a es a a ea necesi a emos:
Una o ma de de ec a qué llamadas al sis ema ealiza un p og ama
Una o ma de bloquea de e minadas llamadas al sis ema
La p ime a es necesa ia pa a ob ene qué llamadas al sis ema son usadas
po cada p og ama, mien as que la segunda nos pe mi i á acaba con aquel
p oceso que u ilice una llamada p ohibida.
3.2. Llamadas al sis ema ealizadas po un p og a-
ma
Pa a e qué llamadas al sis ema ealiza un p og ama, Linux cuen a con
una he amien a llamada s ace1. Si consul amos el manual (man s ace)2,
s ace ejecu a el comando especi icado has a su inalización, in e cep ando
y egis ando las llamadas al sis ema que el p oceso a ealizando, así como
las señales que ecibe. No solo ob iene las p opias llamadas, sino ambién los
a gumen os con los que se llaman y sus alo es de e o no.
El siguien e agmen o de e minal ilus a la ejecución de es a he amien-
a con el comando ls:
$ s ace ls
exec e("/us /bin/ls", ["ls"], 0x7 ebc4d7180 /* 51 a s */) = 0
b k(NULL) = 0x555757b16000
a ch_p c l(0x3001 /* ARCH_??? */, 0x7 d9956 010) =
-1 EINVAL (In alid a gumen )
access("/e c/ld.so.p eload", R_OK) =
-1 ENOENT (No such ile o di ec o y)
opena (AT_FDCWD, "/e c/ld.so.cache", O_RDONLY|O_CLOEXEC) = 3
[... o as llamadas no mos adas]
close(2) = 0
exi _g oup(0) = ?
+++ exi ed wi h 0 +++
Como podemos obse a , has a el comando más simple gene a una eno -
me can idad de llamadas (en el ejemplo no se mues a oda la salida, dado
que ls da luga a 62 llamadas). La opción -c de s ace nos o ganiza la
in o mación de las llamadas ejecu adas en o ma de abla:
1Las ejecuciones se han ealizado sob e una máquina ejecu ando la dis ibución A ch
Linux.
2h ps://man7.o g/linux/man-pages/man1/s ace.1.h ml
3.2. Llamadas al sis ema ealizadas po un p og ama 27
$ s ace -c ls
exe.c in ou ou 2 p p.py py_exe.py es .py
% ime seconds usecs/call calls e o s syscall
------ ----------- ----------- --------- --------- ----------------
19,55 0,000578 44 13 mmap
17,75 0,000525 105 5 opena
[... o as llamadas no mos adas]
0,71 0,000021 21 1 w i e
0,37 0,000011 5 2 ge den s64
------ ----------- ----------- --------- --------- ----------------
100,00 0,002957 49 60 6 o al
Es as ablas nos se án de g an u ilidad pos e io men e, cuándo engamos
que ob ene las llamadas al sis ema que debemos pe mi i ejecu a a los
p og amas y aquellas que debemos bloquea .
3.2.1. Bloquea llamadas al sis ema
Sabe qué llamadas enemos que pe mi i y cuáles enemos que blo-
quea no es ú il si no enemos una o ma e ec i a de ealiza es os bloqueos.
A o unadamen e exis e una llamada al sis ema de Linux que nos pe mi-
e hace jus amen e es o, bloquea las llamadas al sis ema que deseemos,
seccomp(Co be , 2009):
in seccomp(unsigned in ope a ion,
unsigned in lags, oid *a gs);
Sin emba go, es a ez no amos a u iliza di ec amen e es a llamada al
sis ema pa a ealiza es a a ea. Vamos a op a po hace uso de una lib e ía
de C pa a que haga po noso os la in e acción con el sis ema. Conc e amen-
e, la lib e ía libseccomp1, de la cuál amos a da uso de a ias unciones.
En p ime luga , la unción que inicializa el il o:
scmp_ il e _c x seccomp_ini (uin 32_ de _ac ion);
Es a unción inicializa el es ado de un il o de seccomp, lo p epa a pa a
su uso y pone de _ac ion como acción po de ec o. Es o es, qué hace cuándo
el p og ama hace uso de alguna llamada al sis ema que hemos p ohibido.
En nues o caso, la acción po de ec o que más nos in e esa es la de
inaliza el p oceso en iándole una señal SIGSYS, SCMP_ACT_KILL. Con
es e pa áme o, o zamos a los p og amas a inaliza su ejecución si ealizan
alguna llamada al sis ema que no es é pe mi ida explíci amen e. Po ello, en
1h ps://gi hub.com/seccomp/libseccomp

28 Capí ulo 3. Ejecución Segu a
luga de de e mina qué llamadas amos a bloquea , enemos que de e mina
aquellas que amos a pe mi i .
Con el il o inicializado, la siguien e unción nos pe mi e añadi llamadas
al il o, en nues o caso con el obje i o de pe mi i su u ilización:
in seccomp_ ule_add(scmp_ il e _c x c x, uin 32_ ac ion,
in syscall, unsigned in a g_cn , ...);
Como p ime a gumen o le pasamos el il o que ob u imos con la un-
ción an e io . En el segundo, le indicamos cuál se á la acción a ealiza en
caso de que es a llamada se u ilice. Dado que po de ec o, odas las llamadas
es án bloqueadas, debemos indica le cuáles son las que que emos pe mi i ,
con el pa áme o SCMP_ACT_ALLOW. En el siguien e a gumen o, sys-
call, simplemen e enemos que señala la llamada al sis ema que pe mi imos
ejecu a .
Después de es os es a gumen os, podemos añadi un núme o inde e -
minado de condiciones a las eglas. La uncionalidad más des acable es la de
indica el alo de los a gumen os de una cie a llamada. Po ejemplo, pa a
pe mi i que un p og ama pueda esc ibi en la salida es ánda , pe o que no
pueda hace lo en cualquie o o iche o, u ilizamos es os a gumen os ex as.
Con odas las eglas de inidas, lo único que nos al a es ca ga el il o
pa a empeza a bloquea llamadas:
in seccomp_load(scmp_ il e _c x c x);
Le pasamos como a gumen o el il o c eado po seccomp_ini () y a
pa i de ese momen o, odas las llamadas al sis ema que no o men pa e
de la lis a de pe mi idas esul a á en la e minación del p og ama.
Con es as es unciones a nues a disposición, enemos odo lo necesa io
pa a ealiza la implemen ación de un en o no de ejecución de Py hon segu o,
siemp e y cuando pe mi amos las llamadas mínimas que u iliza el in é p e e
al inicia se y aquellas empleadas en la ejecución de un p og ama es ánda .
3.2.2. Llamadas a pe mi i en Py hon
Ob ene las llamadas que ealize el in é p e e de Py hon pa a inicializa
su en o no es an simple como ejecu a un p og ama Py hon acío jun o a
la he amien a s ace:
3.2. Llamadas al sis ema ealizadas po un p og ama 29
$ s ace -c py hon -c ""
% ime seconds usecs/call calls e o s syscall
------ ----------- ----------- --------- --------- ----------------
24,62 0,004492 27 165 13 new s a a
23,84 0,004350 83 52 4 opena
11,65 0,002125 31 68 _sigac ion
10,49 0,001914 22 85 ead
9,89 0,001804 27 65 3 lseek
8,14 0,001486 39 38 32 ioc l
5,94 0,001083 21 51 close
1,58 0,000289 20 14 ge den s64
1,52 0,000278 27 10 b k
1,23 0,000225 5 39 mmap
0,65 0,000119 39 3 dup
0,22 0,000041 41 1 sysin o
0,21 0,000039 39 1 cn l
0,00 0,000000 0 10 mp o ec
0,00 0,000000 0 1 munmap
0,00 0,000000 0 1 _sigp ocmask
0,00 0,000000 0 6 p ead64
0,00 0,000000 0 1 1 access
0,00 0,000000 0 1 exec e
0,00 0,000000 0 3 1 eadlink
0,00 0,000000 0 1 ge uid
0,00 0,000000 0 1 ge gid
0,00 0,000000 0 1 ge euid
0,00 0,000000 0 1 ge egid
0,00 0,000000 0 2 1 a ch_p c l
0,00 0,000000 0 1 u ex
0,00 0,000000 0 1 se _ id_add ess
0,00 0,000000 0 1 se _ obus _lis
0,00 0,000000 0 1 p limi 64
0,00 0,000000 0 1 ge andom
------ ----------- ----------- --------- --------- ----------------
100,00 0,018245 29 626 55 o al
En es e comando, indicamos a s ace que nos mues e un esumen de las
llamadas (opción -c) y que lo haga sob e Py hon ejecu ando el sc ip que se
le pasa po pa áme o (cu iosamen e, opción -c ambién), en es e caso, un
p og ama acío. Si c eamos un p og ama C que pe mi a la ejecución solo de
es as llamadas, debe ía unciona sin p oblema.
Es o no quie e deci que cualquie p og ama Py hon cuya ejecución que-
emos pe mi i no aya a u iliza llamadas di e en es a las ob enidas. Al
mismo iempo, no debemos pensa que pe mi i odas es as llamadas a a
esul a en un en o no lo su icien emen e segu o como pa a ejecu a p o-
g amas sin cuidado. Si somos más obse ado es, en e o as, emos que se
u ilizan las llamadas opena , ead yw i e, con las cuáles un p og ama se ía
capaz de ab i , lee y esc ibi en cualquie iche o del en o no de ejecución.
Es aho a cuándo eco damos los a gumen os ex as de los que dispone
la unción de añadi eglas, seccomp_ ule_add. Con es os, amos a pe mi i
que se ab an, lean y esc iban si cumplen las siguien es condiciones:
30 Capí ulo 3. Ejecución Segu a
opena : no se pe mi e esc ibi ni c ea iche os, es deci , los lags de
la llamada no pueden se O_WRONLY ni O_CREAT. Es o deja la
posibilidad de ab i iche os pa a su lec u a, necesa ia pa a que el in-
é p e e inicie su ejecución.
ead yw i e: solo se puede lee y esc ibi sob e un iche o si es os
son la en ada o salida es ánda , y la salida de e o . Es necesa io
pode lee de en ada es ánda y esc ibi a salida es ánda pa a ealiza
los p oblemas, pe o no pe mi imos que se ealicen sob e ningún o o
iche o.
3.2.3. Implemen ación
Una ez hemos ob enido odo lo necesa io, las unciones a u iliza y cómo
usa las, y las llamadas a pe mi i , pasemos a ealiza la implemen ación. En
p ime luga , de inimos una unción que inicializa el il o y le añade odas
las llamadas que debemos pe mi i como mínimo:
scmp_ il e _c x se up_seccomp(){
scmp_ il e _c x c x = seccomp_ini (SCMP_ACT_KILL);
seccomp_ ule_add(c x, SCMP_ACT_ALLOW, SCMP_SYS(access), 0);
seccomp_ ule_add(c x, SCMP_ACT_ALLOW, SCMP_SYS(a ch_p c l), 0);
... ...
seccomp_ ule_add(c x, SCMP_ACT_ALLOW, SCMP_SYS(sysin o), 0);
//Allow only wi h hese a gumen s
seccomp_ ule_add(c x, SCMP_ACT_ALLOW, SCMP_SYS(opena ), 1,
SCMP_A2(SCMP_CMP_EQ, O_RDONLY));
seccomp_ ule_add(c x, SCMP_ACT_ALLOW, SCMP_SYS(opena ), 1,
SCMP_A2(SCMP_CMP_EQ, O_RDONLY|O_CLOEXEC));
seccomp_ ule_add(c x, SCMP_ACT_ALLOW, SCMP_SYS(opena ), 1,
SCMP_A2(SCMP_CMP_EQ,
O_RDONLY|O_NONBLOCK|O_DIRECTORY|O_CLOEXEC));
//Allow only o s din, s dou y s de
o (in i = 0; i < 3; i++) {
seccomp_ ule_add(c x, SCMP_ACT_ALLOW, SCMP_SYS(w i e), 1,
SCMP_A0(SCMP_CMP_EQ, i));
seccomp_ ule_add(c x, SCMP_ACT_ALLOW, SCMP_SYS( ead), 1,
SCMP_A0(SCMP_CMP_EQ, i));
}
e u n c x;
}
P og ama 3.1: Inicializa el il o
Llamamos a ini () indicándole que la acción po de ec o sea e mina
el p og ama y comenzamos a añadi eglas. Como comen ábamos an e io -
men e, la unción opena solo se pe mi e si no a a esc ibi o c ea un iche o
3.2. Llamadas al sis ema ealizadas po un p og ama 31
nue o, y las unciones ead yw i e solo pa a la en ada y salida es ánda ,
y la salida de e o , que co esponden a los desc ip o es de iche os10, 1 y 2.
Lo único que nos al a es ca ga es e il o sob e un p og ama y p oba
que unciona co ec amen e:
//compile wi h -lseccomp
scmp_ il e _c x c x = se up_seccomp();
cha *a gs[] = { "/us /bin/py hon", a g [1], 0};
pid_ childPid = o k();
i (childPid == 0){
//P oceso hijo
i (seccomp_load(c x) != 0) {
p in ("ERROR: Couldn’ load execu ion il e s.");
exi (-1);
}
exec p(a gs[0], (cha **cons ) &a gs);
}
else{
//P oceso pad e
in e u nS a us;
wai pid(childPid, & e u nS a us, 0);
p in ("Re u ned alue: %d n", e u nS a us);
}
P og ama 3.2: Ca ga el il o y ejecu a un p og ama
En o den, llamamos a la unción que inicializa el il o y c eamos los a -
gumen os pa a ejecu a el p og ama, en es e caso amos a ejecu a p og ama
en Py hon. Hacemos un o k, donde el hijo ejecu a á el p og ama y el pad e
espe a á has a que el hijo e mine.
El hijo, an es de ejecu a el p og ama, ca ga el il o con la unción
seccomp_load. Las eglas es ablecidas son he edadas po el hilo de ejecu-
ción y los hijos, po eso el p og ama ejecu ado con exec p es a á bajo esas
mismas eglas.
Po úl imo y pa a asegu a nos de su co ec o uncionamien o, amos a
ejecu a una se ie de p og amas en Py hon que debe ían hace sal a las
eglas:
Py hon Resul ado
#P in ok, should wo k ine
p in ("ok")
$ ./exe ok.py
ok
Re u ned alue: 0
#Execu e ls, should c ash
os.exec e(’/bin/ls’, ["ls"], {})
$ ./exe exec e.py
Re u ned alue: 159
1h ps://en.wikipedia.o g/wiki/File_desc ip o

Capí ulo 4
Limi ación de Memo ia
En el úl imo apa ado del Es ado del a e explo amos las di e en es o -
mas que enemos a nues a disposición pa a medi la memo ia u ilizada po
un p og ama Py hon y ambién el cómo podíamos limi a su consumo má-
ximo.
A lo la go de es e capí ulo amos a p o undiza en los mecanismos que
u iliza emos en la implemen ación inal, explo ando las di e en es opciones
que nos o ecen y eligiendo las más adecuadas pa a es e p oyec o.
Además, examina emos más de enidamen e el uso de memo ia que hace
Py hon en di e en es si uaciones y p oblemas, pa a demos a su iabilidad
no solo en la p og amación compe i i a en gene al, sino en aquellos p oblemas
con la limi ación de memo ia como un pun o p incipal en su esolución.
4.1. Medición de memo ia
Como imos en el úl imo apa ado del Es ado del a e, amos a u iliza
llamadas al sis ema de Linux pa a ob ene la memo ia máxima u ilizada
po un p oceso Py hon. Conc e amen e, u iliza emos ge usage, cuya docu-
men ación podemos encon a en el manual de Linux y en (Mi chell e al.,
2001).
in ge usage(in who, s uc usage *usage);
Como g an pa e de las llamadas al sis ema, ge usage de uel e 0 en
caso de que éxi o y -1 en cualquie o o caso, es ableciendo la a iable e no
pa a indica el e o . La unción ecibe dos a gumen os. En el p ime o de
ellos, who, le indicamos de “quién” que emos ob ene el uso de ecu sos. Es e
puede se uno de los siguien es:
RUSAGE_SELF: pa a ob ene los ecu sos u ilizamos po el p oceso
ac ual, incluyendo odos los hilos gene ados po el mismo.
39
40 Capí ulo 4. Limi ación de Memo ia
RUSAGE_CHILDREN: pa a solo ob ene los ecu sos u ilizados po
odos los hijos c eados que hayan inalizado su ejecución.
RUSAGE_THREAD: pa a ob ene los ecu sos u ilizados po el hilo
ac ual.
De en e odos ellos, RUSAGE_CHILDREN es el que más se ace ca a lo
que que emos, que es medi únicamen e la memo ia u ilizada po el in é p e e
de Py hon, que se á in ocado desde el código en C como un p oceso hijo.
El segundo a gumen o es el e dade o e o no de la unción, la es uc u a
usage con odos los siguien es usos de ecu sos:
s uc usage {
s uc ime al u_u ime; /* use CPU ime used */
s uc ime al u_s ime; /* sys em CPU ime used */
long u_max ss; /* maximum esiden se size */
long u_ix ss; /* in eg al sha ed memo y size */
long u_id ss; /* in eg al unsha ed da a size */
long u_is ss; /* in eg al unsha ed s ack size */
long u_min l ; /* page eclaims (so page aul s) */
long u_maj l ; /* page aul s (ha d page aul s) */
long u_nswap; /* swaps */
long u_inblock; /* block inpu ope a ions */
long u_oublock; /* block ou pu ope a ions */
long u_msgsnd; /* IPC messages sen */
long u_msg c ; /* IPC messages ecei ed */
long u_nsignals; /* signals ecei ed */
long u_n csw; /* olun a y con ex swi ches */
long u_ni csw; /* in olun a y con ex swi ches */
};
De en e odos ellos usa emos únicamen e u_max ss, a pesa de que
u_ixss, u_id ss y u_is ss es én elacionados con la memo ia y que nos
pod ían esul a se ú iles, ya que ac ualmen e son campos no usados en
Linux.
Si leemos la desc ipción de es e emos que nos de uel e la memo ia
máxima que en algún momen o pe eneció al p oceso y que ue u ilizada
de o ma ac i a, en es e caso signi icando que es u o esidiendo en RAM. La
memo ia de uel a es á medida en kiloby es.
En la misma desc ipción, nos in o ma que en caso de u iliza RUSA-
GE_CHILDREN, el campo indica á el amaño del hijo más g ande, no de
la suma de odos los hijos c eados en el á bol de p ocesos. En nues o caso,
es a limi ación no nos a ec a á, pues solo p e endemos medi la memo ia
u ilizada po un hijo, que ejecu a á a su ez el p og ama Py hon y segui á
siendo el mismo p oceso, pe o además po que Py hon, como hemos is o y
4.2. Limi ación de memo ia 41
e emos más adelan e, usa una can idad de memo ia mucho mayo que un
p og ama en C con la misma uncionalidad, po lo que en cualquie caso, el
campo egis a ía el uso de memo ia de Py hon.
Conociendo más en de alle el uncionamien o de ge usage, amos a co-
di ica un pequeño p og ama que ejecu a un comando pasado po pa áme o
y mues e la memo ia usada po es e al acaba :
#include <s dio.h>
#include <s dlib.h>
//Fo ge usage
#include <sys/ ime.h>
#include <sys/ esou ce.h>
in main(in a gc, cha *a g []) {
sys em(a g [1]);
s uc usage use;
ge usage(RUSAGE_CHILDREN, &use);
p in ("Memo y used: %0.2 MB n", ( loa )(use. u_max ss) / 1024.0);
e u n 0;
}
P og ama 4.1: Uso de memo ia de comando
Con es e p og ama podemos medi la can idad de memo ia que usa cual-
quie o o, simplemen e ejecu ándolo y pasándole po pa áme o cualquie
comando:
El comando ls:
$ ./memuse "ls"
emp y.py hello_wo ld.py memlimi .c mem.py memuse memuse.c p use
Memo y used: 3.52MB
Un p og ama en Py hon:
$ ./memuse "py hon hello_wo ld.py"
Hello wo ld!
Memo y used: 7.66MB
Incluso a sí mismo, si enemos cuidado con los pa áme os:
$ ./memuse "./memuse " ""
Memo y used: 3.58MB
Memo y used: 3.58MB
4.2. Limi ación de memo ia
De la misma o ma u ilizada pa a medi el uso de memo ia, la limi ación
de es a la amos a implemen a u ilizando o a llamada al sis ema de Linux,
42 Capí ulo 4. Limi ación de Memo ia
en es e caso se limi (Mi chell e al., 2001).
in se limi (in esou ce, cons s uc limi * lim);
De nue o, enemos o a unción que de uel e 0 en caso de éxi o y -1 en
caso de e o , es ableciendo la a iable e no con el e o ocu ido.
La unción ecibe dos a gumen os. En el p ime o, esou ce, indicamos
a la unción qué ecu so que emos limi a . En e los ecu sos que podemos
limi a , se encuen an la máxima memo ia i ual (RLIMIT_AS), el iempo
máximo de CPU que puede ocupa (RLIMIT_CPU), el núme o de a chi os
que puede c ea (RLIMIT_FSIZE), y muchos o os que se pueden consul a
en la documen ación. De en e odos ellos nos in e esan especialmen e dos:
RLIMIT_DATA: pa a limi a el máximo amaño de segmen o de da os
del p oceso, que incluye los da os inicializados y sin inicializa y el heap.
El lími e se es ablece en By es y es edondeado hacia abajo en base al
amaño de página del sis ema.
RLIMIT_STACK: pa a limi a el máximo amaño de la pila del p oce-
so. En Py hon es especialmen e impo an e cambia es e lími e debido a
que po de ec o es á limi ado a 8 MiB (8.388.608 By es). Es udia emos
el lími e de ecu sión de Py hon más en p o undidad en la sección 4.3.1.
El hecho de que ambos ecu sos se limi en po sepa ado, pe o que ob-
engamos su suma al medi la memo ia máxima usada es lige amen e p o-
blemá ico. Teó icamen e, si limi ásemos un p og ama a usa un máximo de
50 MiB, an o en da os como el pila, es e se ía capaz de u iliza has a un
máximo de 100 MiB, 50 de da os y 50 de pila, sin que el sis ema ope a i o
le en íe una señal o zándole a e mina . Es e caso ambién lo es udia emos
con más de alle en los siguien es apa ados.
Como segundo a gumen o, enemos que indica le la limi ación que pone-
mos sob e esou ce, con una es uc u a limi :
s uc limi {
lim_ lim_cu ; /* So limi */
lim_ lim_max; /* Ha d limi (ceiling o lim_cu ) */
};
Donde lim_cu indica el e dade o lími e que el sis ema ope a i o im-
pone sob e el p oceso. Si se u iliza un alo supe io a es e, el p og ama se á
e minado de o ma o zosa. Es e alo , conocido como so limi , puede se
modi icado po un usua io sin p i ilegios (es deci , no hace al a se oo en
Linux) desde 0 has a el o o campo de la es uc u a, lim_ha d. Es e ac úa
4.2. Limi ación de memo ia 43
como ha d limi y solo puede se modi icado po un usua io oo . Po ello,
si que emos limi a un p og ama a un alo máximo de memo ia, debemos
modi ica ambos campos, ya que end emos pe misos pa a hace lo. Po o a
pa e, el usua io ejecu a á sin p i ilegios, po lo que no pod á aumen a el
lími e pe mi ido, solo disminui lo, opción que no apo a ía en aja alguna.
Al igual que hicimos pa a la medición de memo ia, amos a esc ibi o o
p og ama en C que ejecu e un comando pasado po pa áme o, limi ando su
memo ia ambién pasada como pa áme o. Además, pa a e si el comando
se ejecu ó co ec amen e cap u amos el esul ado de ejecu a el comando y
lo esc ibimos.
#include <s dio.h>
#include <s dlib.h>
//Fo se limi
#include <sys/ ime.h>
#include <sys/ esou ce.h>
oid limi _memo y(in MB){
s uc limi da a_limi = {MB, MB};
s uc limi s ack_limi = {MB , MB};
se limi (RLIMIT_DATA, &da a_limi );
se limi (RLIMIT_STACK, &s ack_limi );
}
in main(in a gc, cha *a g []) {
long limi = s ol(a g [1], NULL, 10);
limi _memo y(limi *1024*1024);
in e = sys em(a g [2]);
p in ("Re u ned: %d n", e );
e u n 0;
}
P og ama 4.2: Limi a memo ia de un comando
Podemos u iliza lo pa a ejecu a di e en es p og amas, como po ejemplo:
$ ./memlimi 50 "py hon lis _1000000.py"
Re u ned: 0
En es e caso, ejecu amos un p og ama en Py hon que gene a una lis a de
1 millón de en e os, del 1 al 1.000.000. La lis a ocupa, según los esul ados
que imos en el capí ulo 2, al ededo de 47 MiB, po lo que el p og ama
debe ía ejecu a se co ec amen e, hecho que podemos comp oba con el alo
de e o no, 0.
Si bajamos el lími e a 40 MiB, ob enemos el siguien e esul ado:

44 Capí ulo 4. Limi ación de Memo ia
$ ./memlimi 40 "py hon lis _1000000.py"
T aceback (mos ecen call las ):
File "/media/s _TFG/Memo yUseC/lis _1000000.py", line 1, in <module>
l=[i o iin ange(1000000)]
File "/media/s _TFG/Memo yUseC/lis _1000000.py", line 1, in <lis comp>
l=[i o iin ange(1000000)]
Memo yE o
Re u ned: 256
Como e a espe able, el p og ama u iliza más memo ia de la que le hemos
pe mi ido, po lo que el sis ema ope a i o inaliza su ejecución y nos de uel e
algo di e en e a 0. En es a ins ancia además, el in é p e e de Py hon nos
indica la excepción encon ada, Memo yE o e incluso nos dice el segmen o
de código en el que se ha p oducido es a excepción.
4.3. Uso de memo ia de Py hon
Con las o mas ob enidas pa a medi y limi a la memo ia, enemos las
he amien as necesa ias pa a e alua los di e en es p og amas en es os as-
pec os. Al mismo iempo, es as no si en de nada si no conocemos cuán o
enemos que limi a la memo ia en los di e en es ipos de p oblemas, o sim-
plemen e que Py hon sea incapaz de ealiza a eas que o os lenguajes sí
que pueden.
Po ejemplo, en ando de nue o en los jueces en línea, en ¡Acep a el Re o!
la mayo pa e de los p oblemas ienen un lími e de memo ia de 4096 KB,
memo ia de sob a pa a un p og ama en C/C++ que u iliza pocas a iables,
mien as que si nos ijamos en los da os ob enidos en los apa ados de medi-
ción, emos a Py hon u iliza un mínimo de al ededo de 8 MiB únicamen e
pa a inicia su ejecución.
En es e apa ado amos a in es iga e dade amen e la iabilidad de
Py hon como lenguaje en p oblemas donde la limi ación de memo ia se e a
es una pa e impo an e del p oblema.
4.3.1. Lími e de ecu sión
Una écnica muy u ilizada en odo ipo de p oblemas es la ecu sión,
unciones que se llaman a sí mismas una y o a ez.
En e o os, enemos el algo i mo de g a os DFS,Dep h Fi s Sea ch o
búsqueda en p o undidad, u ilizado pa a la búsqueda de componen es cone-
xas, la de ección de ciclos, de ección de puen es y pun os de a iculación,
e c.
El lími e de ecu sión de Py hon es á limi ado po de ec o a 1000 llama-
das. Es e hecho es comp obable con el módulo sys(Van Rossum e al., 2000)
de la lib e ía es ánda y el mé odo ge ecu sionlimi ():
4.3. Uso de memo ia de Py hon 45
impo sys
p in (sys.ge ecu sionlimi ())
P og ama 4.3: ge _ ec_limi .py
$ py hon ge _ ec_limi .py
1000
O de o ma empí ica, con la siguien e unción:
de ec(n):
p in (n)
ec(n+1)
ec(1)
P og ama 4.4: ec_limi .py
$ py hon ec_limi .py
...
995
996
[... e o es no mos ados]
Recu sionE o : maximum ecu sion dep h exceeded while calling a Py hon objec
Po sue e, es e lími e es a i icial, impues o po el mismo in é p e e de
Py hon pa a e i a s ack o e low innecesa ios y no es un lími e del p o-
pio lenguaje, lo cuál queda e lejado al pode se cambiado desde la misma
lib e ía es ánda sin necesidad de p i ilegios de oo :
impo sys
sys.se ecu sionlimi (2000)
p in (sys.ge ecu sionlimi ())
P og ama 4.5: ge _ ec_limi 2.py
$ py hon ge _ ec_limi 2.py
2000
$ py hon ec_limi .py
...
1995
1996
[... e o es no mos ados]
Recu sionE o : maximum ecu sion dep h exceeded while calling a Py hon objec
Lo ideal pa a p og amación compe i i a se ía elimina es e lími e po
comple o, o en su de ec o asigna un alo absu damen e g ande (1000000000)
y desp eocupa se de ello. Haciendo es e es amos an e un escena io simila
46 Capí ulo 4. Limi ación de Memo ia
al de o os lenguajes en donde el desbo damien o es á elacionado con el
consumo de memo ia de la pila y no limi ado po el in é p e e:
impo sys
sys.se ecu sionlimi (1000000000)
de ec(n):
p in (n)
ec(n+1)
ec(1)
P og ama 4.6: ec_limi 2.py
$ py hon ec_limi 2.py
...
20134
20135
Segmen a ion aul (co e dumped)
Ya no ob enemos más el e o de Recu sionE o , debido a que únicamen-
e sal a cuando alcanzamos el lími e au oimpues o po el in é p e e, sino que
di ec amen e ob enemos un Segmen a ion aul . Con e o es an conc e os es
ácil abaja , aunque inalmen e encon amos la espues a con las mismas
he amien as que limi amos noso os mismos la memo ia máxima, en caso
de Py hon el módulo esou ce.
De o ma análoga a limi a , usando se limi , exis e la unción que ob-
iene las limi aciones ac uales de los ecu sos, ge limi , la cuál empleamos
pa a ob ene el amaño máximo de la pila po de ec o en Py hon:
impo esou ce
p in ( esou ce.ge limi ( esou ce.RLIMIT_STACK))
P og ama 4.7: s ack_limi .py
$ py hon s ack_limi .py
(8388608, -1)
La azón del Segmen a ion aul es que el p og ama sob epasa el lími e
de memo ia que puede u iliza en la pila y el sis ema ope a i o inaliza su
ejecución. Es o además nos pe mi e ealiza cálculos ace ca del sob ecos e de
la ecu sión en es e lenguaje: con una limi ación de 8.388.608 by es es capaz
de ealiza un o al de 20.135 llamadas (es e núme o a ía lige amen e en e
ejecuciones), po lo que Py hon u iliza ap oximadamen e 416 by es po cada
llamada ecu si a.
Si hacemos es e lími e ilimi ado, con RLIM_INFINITY, las llamadas
ecu si as con inua án has a u iliza oda la memo ia disponible del sis ema:
4.3. Uso de memo ia de Py hon 47
impo sys, esou ce
sys.se ecu sionlimi (1000000000)
esou ce.se limi ( esou ce.RLIMIT_STACK, [ esou ce.RLIM_INFINITY,
esou ce.RLIM_INFINITY])
de ec(n):
p in (n, esou ce.ge usage(RUSAGE_SELF). u_max ss / 1024)
ec(n+1)
ec(1)
P og ama 4.8: ec_limi 3.py
$ py hon ec_limi 3.py
[... salidas de las llamadas an e io es]
1510281 1304.70703125
Además de la p o undidad, la unción ambién nos mues a la memo ia
u ilizada po el p oceso has a el momen o An es que sal ase un e o de eje-
cución, la úl ima imp esión en la consola co espondía a la llamada 1.510.281,
con un consumo de memo ia ac ual de más de 1.2 GiB.
Es a misma es la azón po la que en los apa ados de limi ación de
memo ia mencionábamos la impo ancia de limi a la memo ia, no solo de
los da os, sino ambién de la pila. El amaño po de ec o de la pila en Py hon
es muy pequeño pa a ejecu a cie os algo i mos ecu si os sob e casos de
p ueba oluminosos, y con las limi aciones que ponemos en el capí ulo de
ejecución segu a no hay nada que los usua ios puedan hace pa a modi ica
es e campo, po lo que ecae sob e noso os el hace lo.
4.3.2. Uso de memo ia en en ada es ánda
En odos los p oblemas de cualquie juez en línea y concu so de p og a-
mación, los da os de en ada se leen po en ada es ánda (s din) y se esc ibe
la salida po salida es ánda (s dou ).
Un ipo de p oblemas de ¡Acep a el Re o! son aquellos con en adas de
muchos elemen os en la misma línea, los cuáles deben lee se de o ma indi-
idual si no que emos sob epasa el lími e de memo ia del p oblema. En e
es os, enemos po ejemplo el 248 - “Los p emios de las agape as”, con un
30 % de MLE, el 129 - “Ma cado es de 7 segmen os” con un 27 % o el 544 -
“Que no se a agan en” con un 24 %.
Es a a ea es muy simple y de hecho la más na u al en los lenguajes ya
disponibles en la página, con scan de C, cin en C++ y Scanne de Ja a.
El p oblema su ge en Py hon, donde no exis e una o ma de lee elemen os
de uno en uno.
La o ma es ánda de lee elemen os de uno a uno en Py hon consis e
en lee la línea en e a como s ing, di idi la lis a po espacios u ilizando
54 Capí ulo 4. Limi ación de Memo ia
Figu a 4.1: Tiempos de lec u a
Figu a 4.2: Uso de memo ia de lec u a

4.3. Uso de memo ia de Py hon 55
Es os esul ados nos mues an que una lec u a e icien e an o en memo ia
como en iempo es posible en Py hon. Cla o es á, los usua ios que se en en en
a p oblemas de es e ipo u ilizándolo deben se conscien es de que lee la
en ada como es án acos umb ados a a esul a en un MLE y que ienen
que in oduci un mé odo al e na i o pa a la lec u a, como el de inido en
es a sección.
Capí ulo 5
Implemen ación
En es e capí ulo nos amos a dedica a jun a odo lo que hemos desa-
ollado en los capí ulos an e io es en un solo p og ama C.
Es e p og ama se i á como ejecu o de p og amas esc i os en Py hon,
sob e los cuáles se á capaz de es ablece di e en es limi aciones. El ejecu o a
su ez debe á asegu a nues o en o no en e a p og amas malin encionados
al mismo iempo que pe mi i á la ejecución de p og amas que no lo sean.
Dado que el ejecu o es á o mado po las di e en es cons ucciones elabo-
adas an e io men e en es e p oyec o, así como algunas nue as pa a alcanza
la uncionalidad deseada de es e, su análisis se ha di idido en di e en es sec-
ciones, donde se explica en más de alle su uncionamien o.
5.1. A gumen os del p og ama
Pa a indica al p og ama odos los pa áme os con los que deseamos eje-
cu a un p og ama Py hon amos a pasa le a gumen os a a és de la consola
de comandos. Un ejemplo de ejecución es el que emos a con inuación:
$ ./exe - 1000 -m 15000 -i .in -o .ou .py
En es e caso, indicamos al p og ama (exe) que es ablezca el lími e de
iempo en 1000 (medido en milisegundos), el lími e de memo ia en 15000 (en
kibiby es), que la en ada del p og ama es á en el iche o .in y debe esc ibi
sob e el iche o .ou . Y inalmen e, que odo es o aplique sob e la ejecución
del p og ama .py.
El análisis de a gumen os del p og ama abaja sin p oblemas en e a a -
gumen os deso denados y a la posición del p og ama a ejecu a . El siguien e
comando es igual de álido que el an e io :
$ ./exe -i .in - 1000 .py -o .ou -m 15000
Pa a e odas las opciones que nos o ece el p og ama, enemos a nues a
disposición el a gumen o -h:
57
58 Capí ulo 5. Implemen ación
$ ./exe -h
Usage: sudo ./exe [OPTIONS] PROGRAM
Please, execu e as supe use
Run p og am wi h es ic ions
- , -- ime_limi =TIME(ms) se maximum CPU ime o
TIME milliseconds
-m, --memo y_limi =MEMORY(kB) se maximum MEMORY use in kibiby es
-i, --inpu _ ile=FILE se he inpu ile
-o, --ou pu _ ile=FILE se he ou pu ile
-c, --compa e_ ile=FILE se he ile o be compa ed
wi h he ou pu
-s, --sa e_py hon use py_exe.py as execu o
-p, --pypy3 use pypy3 ins ead o cpy hon,
o ces sa e_py hon mode
-n, --no_ou pu execu e wi hou logging
-h, --help displays his
Al lado de cada a gumen o se mues a una pequeña explicación de su
uncionamien o. Igualmen e, amos a comen a b e emen e cada uno de ellos:
- : es ablece, en milisegundos, el iempo máximo du an e el que se
ejecu a á el p og ama. Si supe a ese iempo, se e mina á su ejecución
con el en ío de una señal. Si no se indica, el iempo lími e po de ec o
se es ablece en 9.999 segundos.
-m: es ablece, en kibiby es, la memo ia máxima que se le pe mi e al
p og ama u iliza . Es a limi ación se aplica an o al heap como a la
pila del p og ama. Si se supe a es e lími e, se inaliza la ejecución del
p og ama. Si no se indica, la memo ia máxima se es ablece en 1 GiB.
-i y-o: indican, espec i amen e, el iche o que con iene la en ada
del p og ama y el iche o donde iene que esc ibi su salida. En caso de
no es a p esen e alguno de ellos, se lee / esc ibe a pa i de la en ada
/ salida es ánda .
Al mismo iempo que ob enemos ambos iche os, se ealiza el duplicado
de la en ada o salida es ánda sob e ellos. Con es o conseguimos que el
p og ama que ejecu a simplemen e lea y esc iba en las es ánda , dado
que no iene pe misos pa a esc ibi en iche os y ampoco que emos
que el usua io se p eocupe po dónde lee o esc ibi .
-c: es ablece el iche o con el que se compa a á la salida del p og ama.
Si no se indica, simplemen e no se hace compa ación y se acep a su
ejecución.
-s: indica al p og ama que la es icción de llamadas al sis ema y el
cambio de di ec o io al ch oo se ealice den o de un p og ama auxilia
Py hon. Es e p og ama lo imos en la sección de Ejecución Segu a,
donde es ingimos las llamadas u ilizando di ec amen e Py hon.
5.2. Ejecución de Py hon 59
-p: indica al p og ama que la ejecución no se ealice con la implemen-
ación es ánda de Py hon,CPy hon, sino con una al e na i a esc i a
en Py hon pu o, PyPy3. Dado que es a implemen ación ealiza llama-
das al sis ema di e en es, es a opción ue za la opción an e io , ejecu a
median e el in e media io.
-n: la ejecución se ealiza sin esc ibi en consola.
-h: mues a el menú de ayuda.
5.2. Ejecución de Py hon
5.2.1. Compilación
El p ime paso que se ealiza sob e el p og ama a ejecu a es compila lo.
Py hon es un lenguaje in e p e ado, po lo que la ase de compilación no
es muy es ic i a y los únicos e o es que a a de ec a de o ma habi ual
son los de inden ación (Py hon depende comple amen e del inden ado pa a
econoce los bloques de códigos, ya que ca ece de las ípicas lla es de o os
lenguajes),
El mismo sis ema de ejecución es el enca gado de ealiza la compila-
ción. En caso de que es a de luga a algún e o , de ol e émos un CE y no
ejecu a emos el p og ama. La compilación se ealiza median e la lib e ía de
Py hon,py_compile(Van Rossum y D ake, 1995, C. 32.10) con el siguien e
comando:
py hon -m py_compile ile.py 2> compila ion_ou pu
donde ile.py es el p og ama a ejecu a . El esul ado de la compilación se
gua da en un iche o llamado compila ion_ou pu el cuál, en caso de que la
compilación esul ase e ónea, nos acili a á el mos a lo al usua io.
5.2.2. Es ablece lími es y es icciones
Si la compilación ha esul ado exi osa, lo siguien e que enemos que es a-
blece an es de pode ejecu a son los lími es que nos exigen los a gumen os.
Es os son, el lími e de iempo, el de memo ia y las es icciones a llamadas
de sis ema.
Las limi aciones a la memo ia y a las llamadas se ealizan al y cómo
hemos is o en los capí ulos an e io es, mien as que la del iempo ene-
mos que desa olla la en es e apa ado. Dado que no es una pa e sob e la
que ayamos a p o undiza , se ha u ilizado casi ín eg amen e es a plan illa1,
adap ándola pa a ejecu a Py hon.
1h ps://www.linuxp og ammingblog.com/code-examples/
signal-wai ing-sig imedwai

60 Capí ulo 5. Implemen ación
Den o del ejecu o , el es ablecimien o del lími e de iempo es el siguien e:
imeou . _sec = ( ime_ )( ime_limi _ns / (long)S_TO_NS);
imeou . _nsec = ime_limi _ns % S_TO_NS;
sigemp yse (&mask);
sigaddse (&mask, SIGCHLD);
i (sigp ocmask(SIG_BLOCK, &mask, &o ig_mask) < 0) {
pe o ("sigp ocmask");
exi (1);
}
La es uc u a imeou gua da el iempo lími e ob enido de los pa áme os
en dos campos, segundos y nanosegundos, po lo que enemos que ex ae
ambas mé icas de nues o lími e en nanosegundos.
A con inuación, inicializamos el conjun o de señales (sigse _ )mask y le
añadimos la señal SIGCHLD. Po úl imo, añadimos es e nue o conjun o a
las señales bloqueadas con sigp ocmask(). Es o ha á que el p oceso igno e
es a señal y le pe mi i á ejecu a se sin p oblema. Es e conjun o de señales
bloqueadas son he edadas po los hijos al hace o k() y al cambia de
p oceso con un exec(), po lo que con inua á haciendo su unción du an e
la ejecución de Py hon.
5.2.3. Ejecución
La ejecución comienza ob eniendo el iempo ac ual, pa a pode epo a
el iempo o al de ejecución. Idealmen e, es a a ea se ealiza ía jus o an es
de cambia de p oceso a Py hon, pe o es o lógicamen e a a ocu i en un
hijo, po lo que su asignación no se ía isible en el pad e.
Pa a ob ene el iempo ac ual, u ilizamos la unción ge imeo day():
i (ge imeo day(&s a ime,NULL))
pe o ("ge ing ime");
Lo siguien e es el o k(), que nos di ide la ejecución en dos pa es, la
del hijo y la del pad e. Es e úl imo se queda espe ando a que el hijo inalice,
o en su de ec o a manda le una señal de SIGKILL si supe a el iempo lími e.
En o o caso, ob iene el alo de e o no del hijo, que se á el del p og ama
Py hon ejecu ado.
El hijo po o a pa e, se dedica á a p epa a el en o no pa a la ejecución
del p og ama. Si es necesa io, copia á el p og ama a ejecu a sob e el ch oo .
A con inuación cambia á di ec o io aíz po la ca pe a c eada en la sección
de Ejecución segu a median e ch oo y ca ga á el il o de llamadas a sis ema
sob e sí mismo:
5.3. Resul ados de la ejecución 61
cha command[512];
sp in (command, "cp %s oo / %s", p ogpa h, p ogname);
sys em(command);
ch oo (" oo /");
chdi ("/");
i (seccomp_load(c x) != 0) {
p in (s de , "ERROR: Couldn’ load execu ion il e s.");
exi (-1);
}
En úl imo luga y según lo que indiquen los pa áme os, iniciamos la
ejecución del p og ama Py hon con la con igu ación adecuada. Tenemos un
o al de 3 posibilidades:
Ejecución con CPy hon di ec a: en donde la a ea de es ingi las
llamadas y el ch oo ecae sob e el ejecu o , la si uación explicada
an e io men e.
Ejecución con CPy hon con un p og ama in e media io: en luga de se
el ejecu o el enca gado de es a a ea, la elegamos sob e un p og ama
in e medio esc i o en Py hon. Es e p og ama lo imos en la sección
de Res icción de llamadas al sis ema como más es ic i o, ya que el
in é p e e es á inicializado, lo que nos pe mi e mayo es es icciones
sob e las llamadas.
Ejecución con PyPy3: en luga de u iliza el in é p e e po de ec o de
Py hon,CPy hon, el p og ama se ejecu a á con PyPy3, la implemen-
ación al e na i a. Es a opción ue za el uso del p og ama in e medio,
ya que la inicialización de PyPy3 u iliza llamadas al sis ema que de
ninguna mane a que emos pe mi i .
5.3. Resul ados de la ejecución
Al inaliza la ejecución del p og ama, ya sea de o ma exi osa o o zada
po el sis ema, el ejecu o ecibe el alo de salida de es e. Es esponsabilidad
del ejecu o ecopila las es adís icas de ejecución del p og ama inalizado.
En p ime luga , así como an es de la ejecución ob u imos el iempo
de inicio, ob enemos el iempo de inalización de la misma o ma. Con una
simple es a en e ambos (en es e caso 2, una pa a los segundos y o a pa a
los nanosegundos) es ablecemos el iempo de ejecución o al. En caso de que
la inalización ocu ie a a causa de supe a el iempo lími e, se es ablece en
una a iable que se ha alcanzado el lími e, al mismo iempo que e minamos
su ejecución con un kill.
62 Capí ulo 5. Implemen ación
oid ge _ ime_ms(){
in seconds_elapsed = (end ime. _sec - s a ime. _sec);
long mic oseconds_elapsed = (end ime. _usec - s a ime. _usec);
ime_elapsed = (long)(seconds_elapsed) * 1000 +
(mic oseconds_elapsed / 1000);
}
En segundo luga , ob enemos la memo ia máxima usada. Es e p oceso
es igual que el explicado en la sección de Medición de memo ia, u iliza la
unción ge usage sob e RUSAGE_CHILDREN y el campo u_max ss. En
caso de que la memo ia u ilizada sea supe io a la pe mi ida, ma camos que
hemos llegado a un memo y limi :
oid ge _memo y_kb(){
ge usage(RUSAGE_CHILDREN, &use);
memo y_usage = use. u_max ss;
i (memo y_usage * 1024 > memo y_limi _by es)
memo y_limi _ eached = 1;
}
En e ce luga , con el alo de e o no y las ma cas de lími e de iempo
y memo ia, podemos es ablece si la ejecución ue in e umpida po alcan-
za alguno de es os lími es, si inalizó co ec amen e o si inalizó de o ma
ab up a, pe o no a consecuencia de alcanza ningún lími e. Es a e ce a cau-
sa engloba odo ipo de e o es du an e la ejecución del p opio p og ama,
como po ejemplo di idi po ce o.
Es e e o es conocido como Run Time E o oRTE y lo amos a ob ene
a pa i de los campos mencionados:
i ( e u nS a us && ! ime_limi _ eached && !memo y_limi _ eached){
i ( e u nS a us == 159)
es ic ed_ unc ion = 1;
un_e o _ eached = 1;
}
Un p og ama da como esul ado RTE cuando su alo de e o no no es
ce o (no sea exi oso) y no haya alcanzado ningún lími e.
Con ese mismo alo de e o no, podemos in e i qué ipo de excepción
se p odujo, con una pa icula en men e, la de una llamada al sis ema p ohi-
bida. Conc e amen e, el e o no del alo 159 nos dice que el p og ama
inalizó a causa de las eglas que impusimos sob e él. Po es o, si el alo
es 159, indicamos que se ha u ilizado una unción p ohibida, en la a iable
es ic ed_ unc ion.
P o undizando un poco en los alo es de e o no de un p oceso, aquellos
supe io es a 128 indican qué señal p odujo la inalización de su ejecución. A
5.3. Resul ados de la ejecución 63
cada señal en Linux le co esponde un núme o1, empezando en 1 con la señal
SIGHUP. Sabiendo que la señal que inaliza la ejecución cuando se p oduce
una llamada bloqueada es SIGSYS, la núme o 31, ob enemos 159 como alo
de e o no a espe a .
En úl imo luga , y solo en caso de que la inalización enga éxi o (el alo
de e o no sea ce o), enemos que comp oba que la salida del p og ama es
co ec a. Es a a ea solo se ealiza si un iche o con los da os co ec os ha
sido p opo cionado en los a gumen os del ejecu o .
La implemen ación del compa ado es ex emadamen e sencilla, dada su
baja impo ancia en el p oyec o en gene al. Así, es a se ealiza median e la
siguien e unción:
oid check_answe (){
i (memo y_limi _ eached || ime_limi _ eached ||
un_e o _ eached || !exis s_compa e_ ile)
e u n;
cha command[512];
sp in (command, "cmp -s %s %s", ou pu _ ile_s ,
compa e_ ile_s );
in e = sys em(command);
i ( e )
w ong_answe = 1;
}
Comp obamos si la ejecución inalizó co ec amen e con una disyunción
en e los cua o e o es posibles al mismo iempo que comp obamos la exis-
encia de un a chi o a compa a . La compa ación se ealiza con la he a-
mien a cmp de Linux, que compa a by e a by e los iche os y mues a po
pan alla las di e encias encon adas. Como no que emos sabe las di e encias,
solo que emos sabe si son iguales o di e en es, usamos la opción -s pa a no
mos a las. Si el alo de e o no es 0, los iche os son iguales, si es o o alo ,
es os di ie en en al menos 1 by e, po lo que ma camos que la espues a es
e ónea.
La he amien a de compa ación esul a muy ú il en es a si uación, don-
de solo que emos una o ma ápida de comp oba si la salida es idén ica al
iche o co ec o, pe o p esen a se e as limi aciones que no le pe mi i ían un-
ciona como co ec o de un juez decen e. La más impo an e de odas es su
comple a in lexibilidad en la compa ación, lo cual ha ía comp oba la co ec-
ción de p oblemas que abajen con núme os en pun o lo an e p ác icamen e
imposible.
Una posible mejo a se ía la de añadi un nue o pa áme o al p og ama,
que le indicase el p og ama que se a a ocupa de la co ección de la salida del
p og ama. De es a o ma, si el p oblema en pa icula lo equie e, podemos
esc ibi un compa ado especí ico pa a él, que se enca gue de comp oba la
1h ps://man7.o g/linux/man-pages/man7/signal.7.h ml
70 Capí ulo 6. Validación
Como habíamos p e is o, el ejecu o po de ec o no de uel e ningún RF
en el conjun o de alidación, lo que nos o ece una con ianza bas an e ele ada
de su co ección. A pesa de es os esul ados, no debemos con ia nos sob e
su alidez, pues el conjun o de p oblemas e aluados palidece an e el olumen
de p og amas que se en en a ía en una si uación eal. Es po es o que se ía
impo an e es a a en os a es e e edic o en un en o no eal y e alua cada
si uación de o ma indi idual.
A con inuación e aluamos el ejecu o que u iliza un p og ama in e medio
en Py hon pa a es ingi las llamadas.
$ py hon sc ip TRAIN S
...
VER: AC WA TLE MLE RTE CE RF
NUM: 723 79 1 0 0 0 147
Dado que enemos un o al de 147 e edic os RF, en es e caso amos a
ene que abaja un poco más pa a esol e los. De nue o, es e compo a-
mien o e a más o menos espe ado, pues el en o no pe mi e la ejecución de
10 llamadas al sis ema, mien as que el ejecu o en C pe mi e casi 50.
Pa a ob ene la llamada al sis ema que ha p oducido el e o , amos a
ol e a u iliza una he amien a que ya conocemos, s ace. Además, hemos
modi icado el sc ip de ejecución de p og amas pa a que, en caso de p odu-
ci se un RF, ejecu e el siguien e comando:
s ace - ./exe p oblem.py - 10000 -i inpu .in -o ou -s
-c ou pu .ou 2>&1 | g ep -B 1 "killed" | head -1
En donde:
s ace - : ob iene la aza de la ejecución, no solo del p og ama indi-
cado, sino ambién de sus hijos.
./exe p oblem.py - 10000 -i inpu .in -o ou -s -c ou pu .ou : in-
oca la ejecución de p oblem.py con un lími e de iempo de 10 segundos,
usando la en ada con enida en el iche o inpu .in, esc ibi su salida en
ou y compa a la con el iche o ou pu .ou . Además, ejecu a u ilizando
el p og ama Py hon de in e media io.
2>&1: edi ige la salida de e o a la salida es ánda .
g ep -B 1 "killed": ob iene la p ime a línea de odo el ex o que con-
iene la cadena killed.
head -1: dada una línea de ex o, ob iene la an e io .
En esumen, ejecu amos de nue o el p og ama en el en o no con los
mismos pa áme os, al mismo iempo que ob enemos su aza. Cuando acaba,
ob enemos la línea an e io a la inalización o zosa del p og ama, que nos

6.2. Validación 71
di á la llamada al sis ema que ha p o ocado es a inalización. En el siguien e
agmen o emos la aza del p og ama y la llamada que causó el p oblema:
[pid 22736] munmap(0x7 4bd9cb 000, 299008) = ?
[pid 22736] +++ killed by SIGSYS (co e dumped) +++
Vemos que, e ec i amen e, se a a de una llamada bloqueada, munmap,
que si accedemos a su en ada en el manual1, c ea un nue o mapeo de di ec-
ciones i uales del p oceso. Es a llamada se p oduce cuando Py hon necesi a
mayo á ea de memo ia, po lo que no es una unción pelig osa po sí misma
y la debemos pe mi i . En caso de que la memo ia pedida sea muy ele ada,
el lími e de memo ia es ablecido se enca ga á de ello.
El p oceso de ob ene las llamadas al sis ema ealizadas es i e a i o, po
lo que amos a inicia la ejecución de odo el sc ip desde el inicio has a que
es a inalice odos los p og amas co ec amen e. Una ez hemos llegado a ese
pun o, hacemos un esumen de las nue as llamadas pe mi idas:
munmap: c ea un nue o mapeo de di ecciones i uales.
m emap: expande un mapeo de memo ia exis en e.
mad ise: p egun a al ke nel ace ca de un ango de memo ia, con el
obje i o de mejo a el endimien o.
mp o ec : p o ege una egión de memo ia pa a el p oceso.
opena : ealiza las mismas acciones que open con lige as di e encias. Al
igual que en el p og ama en C, solo pe mi imos es a llamada cuando
el iche o no se ab e pa a esc ibi (O_WRONLY) o in en a c ea lo
(O_CREAT).
s a : ob iene in o mación de un iche o. El in é p e e de Py hon la
u iliza pa a impo a los módulos y po an o pa a accede a la lib e ía
es ánda . Po es a azón, es comple amen e necesa ia la llamada.
new s a a : ealiza la misma uncionalidad que s a , con lige as di-
e encias en su uso.
ge den s64: lee las en adas de un di ec o io. U ilizado ambién en la
ca ga de módulos.
Pe mi iendo la ejecución de es as llamadas, además de las que ya pe -
mi íamos, el p ime conjun o de p og amas se ejecu a comple amen e sin
ningún RF.
1h ps://man7.o g/linux/man-pages/man2/mmap.2.h ml
72 Capí ulo 6. Validación
$ py hon sc ip TRAIN S
...
TRAIN RESULTS
VER: AC WA TLE MLE RTE CE RF
NUM: 803 87 4 0 56 0 0
Con es os cambios, el ejecu o de Py hon ob iene exac amen e los mis-
mos e edic os que el ejecu o po de ec o. Comp obemos si las es icciones
ac uales pe mi en la ejecución del conjun o de alidación:
$ py hon sc ip TEST S
...
TEST RESULTS
VER: AC WA TLE MLE RTE CE RF
NUM: 748 102 18 0 70 0 0
E ec i amen e, no ob enemos ningún RF. Lo úl imo que nos queda ía po
alida es el ejecu o de PyPy3, que u iliza de o zosamen e el in e media io
pa a bloquea las llamadas. Los esul ados del conjun o de en enamien o
son los siguien es:
$ py hon sc ip TRAIN P
...
TRAIN RESULTS
VER: AC WA TLE MLE RTE CE RF
NUM: 791 86 3 0 70 0 0
La azón po la que PyPy3 ob iene menos AC,WA yTLE que el es o
y ob iene más RTE es debido a que, al u iliza una e sión an e io de
Py hon, los módulos s ing y ac ions no es án disponibles, po lo que
los p og amas allan an es de inicia se. Ob iando es e hecho, emos que no
se ha gene ado ningún e edic o RF, po lo que en es e apa ado damos po
bueno su uncionamien o. Pa a inaliza , comp obemos que la ejecución del
conjun o de alidación es co ec a:
$ py hon sc ip TEST P
...
VER: AC WA TLE MLE RTE CE RF
NUM: 741 96 14 0 87 0 0
En es os p og amas ol emos a ene el mismo p oblema, más RTE a
consecuencia del uso de módulos que no se encuen an en PyPy3. Como lo
que ealmen e nos in e esa, el núme o de RF, es ce o, pasa la alidación.
6.2.2. E ec os del en o no sob e el iempo y la memo ia
Teniendo una mayo con ianza en las capacidades del en o no, con inue-
mos con las alidaciones. En es e apa ado comp oba emos si exis en di e-
encias en el iempo de ejecución y uso de memo ia en e el simple uso de
6.2. Validación 73
Py hon, con cualquie a de las implemen aciones y la ejecución den o del
en o no, donde a los p og amas se les es ablecen lími es de iempo, memo ia
y llamadas disponibles.
Los p og amas u ilizados pa a medi las di e encias se co esponden con
implemen aciones sencillas de algunos algo i mos clásicos, ope aciones de
lec u a / esc i u a, o dena una lis a y más. En la siguien e abla se mues an
los iempo ob enidos en la p ime a pa e de las p uebas, en milisegundos. Las
es p ime as ilas mues an los iempos de ejecución de la implemen ación
CPy hon, la p ime a ue a del en o no, la segunda es ingiendo las llamadas
desde el ejecu o en C (CPy hon C en la abla) y la e ce a u ilizando el
p og ama Py hon in e medio pa a bloquea las llamadas (CPy hon S). Las
dos úl imas mues an la ejecución del p og ama u ilizando PyPy3 ue a del
en o no en la p ime a y la ejecución den o de él (PyPy3 S en la abla) en
la segunda:
I/O O dena Mon ículo G a os
Inpu Ou pu Inse a C ea Floyd Dijks a K uskal
CPy hon 1.134 1.739 1.611 1.162 650 12.673 3.757 3.464
CPy hon C 1.116 607 1.899 1.378 910 12.901 4.505 3.720
CPy hon S 1.101 645 1.968 1.314 990 12.861 4.789 4.043
PyPy3 366 1.274 1.078 966 968 523 2.996 3.979
PyPy3 S 642 732 1.401 1.289 1.468 847 3.187 4.391
Si igno amos po un momen o los esul ados de la salida, las di e encias
de iempos de ejecución son más o menos cons an es: al ededo de 300 mili-
segundos en el caso del ejecu o po de ec o (en la abla CPy hon C), unos
450 si añadimos el ejecu o in e media io (CPy hon S en la abla) y de nue-
o unos 300 pa a PyPy3. Es os esul ados e an espe ados, ya que además de
la p opia ejecución es amos añadiendo es icciones ex a que suponen una
sob eca ga.
La p ueba de salida, Ou pu en la abla, simplemen e esc ibe un millón
de en e os a la salida es ánda . La so p enden e di e encia en e la ejecución
no mal y en el en o no puede se debida a que, al medi el iempo en la
ejecución no mal se ha edi igido la salida a un iche o desde la e minal,
mien as que en el en o no se esc ibe con no malidad a salida es ánda , que
ha sido edi igida al iche o indicado.
Análoga a la abla an e io , en la siguien e enemos la memo ia medida en
KiB u ilizada po cada uno de es os p og amas du an e la misma ejecución:
I/O O dena Mon ículo G a os
Inpu Ou pu Inse a C ea Floyd Dijks a K uskal
CPy hon 8.696 8.092 240.056 240.124 240.108 13.568 148.972 94.572
CPy hon C 9.816 9.696 239.084 239.612 239.152 13.080 148.024 94.060
CPy hon S 12.652 12.384 243.900 243.716 243.708 17.240 153.012 98.400
PyPy3 68.020 68.284 308.632 328.668 308.124 63.344 133.904 133.592
PyPy3 S 78.364 78.112 319.016 319.000 317.280 74.836 148.856 147.056
74 Capí ulo 6. Validación
La di e encia de memo ia u ilizada es p ác icamen e nula en el en o no
po de ec o, siemp e y cuando el p og ama haga un ue e uso de la me-
mo ia. Así, en las p uebas de en ada y salida donde la memo ia u ilizada
es mínima, exis e una di e encia de al ededo de 2.000 KiB. El uso de me-
mo ia ejecu ando con el in e media io es mucho más egula , u iliza ce ca
de 4.000 KiB ex a en odos los p og amas. Po úl imo, PyPy3 es igual de
cons an e, con 10.000 KiB ex a de memo ia, excep uando en la inse ción en
un mon ículo, que po alguna azón u iliza menos memo ia en el en o no.
En la segunda pa e de las p uebas enemos la c iba de E a ós enes1,
dos p og amas que suman aíces cuad adas y p og amas que emplean uel a
a ás pa a ob ene odos los subconjun os y pe mu aciones de una lis a. Al
igual que an es, p ime o analizamos el iempo de ejecución y luego el uso de
memo ia:
Núme os Vuel a a ás
C iba Sq Sum Sq Sum Op Subconjun os Pe mu aciones
CPy hon 1.313 1.669 1.201 1.2327 6200
CPy hon C 1.348 1.754 1.318 12.720 6.186
CPy hon S 1.480 1.743 1.387 13.104 6.404
PyPy3 49 209 67 503 881
PyPy3 S 303 447 337 1.448 1.190
Los esul ados de es a segunda p ueba son muy pa ecidos a los de la
an e io , po lo que no enemos mucho que comen a sob e ellos. La ejecución
en el en o no po de ec o es lige amen e más len a que la del in é p e e po
sí mismo, usa el in e media io alen iza un poco más es e alo , cosa que
ambién le ocu e a PyPy3.
Respec o al uso de memo ia, enemos ambién esul ados muy simila es:
Núme os Vuel a a ás
C iba Sq Sum Sq Sum Op Subconjun os Pe mu aciones
CPy hon 8.784 403.996 8.332 7.816 8.088
CPy hon C 10.116 403.088 9.812 9.744 10.048
CPy hon S 12.472 408.000 12.296 12.668 1.2552
PyPy3 61.264 138.440 57.444 67.716 67060
PyPy3 S 73.964 151.488 73.052 77.616 77.220
Obse amos de nue o los mismos enómenos. Si el p og ama u iliza mu-
cho la memo ia apenas exis e di e encia en e el en o no po de ec o y la
ejecución es ánda de Py hon, mien as que cuando no lo hace, la di e encia
se es ablece en o no a 2.000 KiB. Po o a pa e, al igual que en las p ue-
bas an e io es, usa el in e media io penaliza en 4.000 KiB ex as y PyPy3
u iliza al ededo de 10.000 KiB más.
1h ps://en.wikipedia.o g/wiki/Sie e_o _E a os henes
Capí ulo 7
Conclusiones
A lo la go de es e abajo hemos conseguido desa olla de o ma sa is ac-
o ia un sis ema de ejecución de p og amas en Py hon, de o ma que es a se
ealiza en un en o no segu o an e código malin encionado y que la memo ia
u ilizable es é limi ada al alo que le indiquemos.
El en o no inal es capaz de ejecu a cualquie p og ama en Py hon, dán-
donos la posibilidad de limi a an o iempo de ejecución como memo ia
máxima, así como indica los iche os de en ada y salida del p og ama, y un
iche o pa a ealiza la compa ación y ob ene el e edic o inal.
La limi ación de memo ia inalmen e se ealizó median e llamadas al
sis ema de Linux. Es o es su icien e pa a el alcance obje i o del p oyec o,
que e a el de desa olla lo pa a es a misma pla a o ma, pe o sigue siendo
una limi ación a ene en cuen a.
Respec o a la p opia limi ación, debemos habla sob e sus ca encias. En
p ime luga , enemos que las limi aciones se ealizan sob e el segmen o de
memo ia de da os (RLIMIT_DATA) y sob e el amaño de la pila (RLI-
MIT_STACK), mien as que la medición de la memo ia máxima ob iene el
amaño máximo de memo ia esiden e en memo ia, que es la suma de am-
bas. En p og amas que hacen uso in ensi o an o de da os como de la pila, la
limi ación de memo ia no ac úa sob e ellos has a que algún amaño de me-
mo ia supe e el es ablecido, lo que eó icamen e pe mi i ía a los p og amas
llega a u iliza el doble de memo ia del pe mi ido, la mi ad en los da os y
la o a en la pila. Con un ejemplo:
Si es ablecemos el lími e en 100 MiB, es a limi ación se aplica sob e la
memo ia de da os en 100 MiB y sob e la memo ia de pila en 100 MiB.
El sis ema ope a i o no inaliza ía la ejecución del p og ama has a que
alguna de es as limi aciones se alcance, pe mi iendo que un p og ama
que u ilice 90 MiB de da os y 90 MiB de memo ia, a pesa de se
supe io a los lími es es ablecidos po sepa ado.
Es a ca encia solo a ec a a la p opia ejecución, ya que el p og ama ejecu-
75

76 Capí ulo 7. Conclusiones
o ob iene po sepa ado la máxima usada y si es supe io al lími e, de uel e
un Memo y Limi Exceeded.
La es icción de llamadas al sis ema u ilizando seccomp depende ue e-
men e de que su ejecución se ealice en un Linux que compa a las mismas
llamadas que el u ilizado pa a desa olla el p oyec o. Pa a las es icciones
ambién es impo an e la e sión de Py hon con la que es amos ejecu ando,
pues un lige o cambio sob e cómo ealiza cie as unciones pod ía hace que
el en o no deje de se capaz de ejecu a lo. Es o pod ía ocu i si se cambia
la u ilización de una llamada al sis ema po o a que ealiza i ualmen e la
misma uncionalidad, como po ejemplo el uso de opena yopen.
Respec o a es e úl imo pun o, comen a que, en el sis ema de ejecución
inal, al y como imos en la ase de alidación, se pe mi e la ape u a de
iche os siemp e y cuando es o sea únicamen e pa a lec u a. Con es o, un
usua io se ía capaz de ab i iche os en el en o no y lee sus con enidos, lo
cual conside emos que es ino ensi o po dos mo i os:
En p ime luga , ab i los iche os es lo único que se ía capaz de hace ,
no se pe mi e el c ea los ni esc ibi , ni ejecu a nada den o del en o no.
En segundo luga , dado que se ejecu a sob e un di ec o io aíz que
lo único que con iene es lo necesa io pa a ejecu a Py hon, no exis-
en iche os en el mismo que esul en en ninguna ulne abilidad del
en o no.
Vemos como es a debilidad del en o no es solucionada en pa e po ch oo .
El en o no de ch oo desa ollado pe mi e la ejecución comple a del in é -
p e e de Py hon en su in e io y solamen e del mismo in é p e e, pues no
con iene ninguna o a he amien a que encon a íamos habi ualmen e en Li-
nux.
A su ez, es o nos ha pe mi ido limi a los módulos que el usua io iene a
su disposición. Es o lo conseguimos du an e la c eación del ch oo , ob enien-
do las dependencias y iche os que ab e un p og ama en Py hon enca gado de
impo a odos los módulos que amos a pe mi i . Es os ue on seleccionados
manualmen e desde la colección de la lib e ía es ánda de Py hon(Van Ros-
sum y D ake, 1995), en base a su u ilidad y necesidad en la p og amación
compe i i a. Así, los módulos que o ecen las di e en es es uc u as de da os
es án disponibles, mien as que aquellos e e en es a la ejecución pa alela y el
mul ihilo no lo es án. La lis a comple a de módulos pe mi idos se encuen a
en el iche o modules.py.
Finalmen e, en la ase de alidación ob u imos un conjun o mode ada-
men e g ande de p oblemas con en adas y salidas pa a los mismos y p oba-
mos a ejecu a los den o del en o no. Es o nos p opo cionó in o mación i al
pa a el p oyec o:
7.1. T abajo u u o 77
En p ime luga , nos obligó a e isa las llamadas al sis ema es in-
gidas, ya que algunos p og amas que conside amos e an adecuados e-
sul aban inalizados po ealiza llamadas que no pe mi íamos. Pa i-
cula men e, e minamos pe mi iendo la ejecución de a ias llamadas
elacionadas con el espacio de memo ia, pa a aumen a lo o disminui -
lo. Es o ocu e en p oblemas que, po ejemplo, ob ienen un a ay de
la en ada, y su amaño a ía según el caso de p ueba. Es o p o oca-
ba que en cada caso de p ueba la memo ia necesi ada ue a di e en e,
esul ando en las llamadas que es aban bloqueadas.
En segundo luga , nos o eció in o mación ace ca de las penalizaciones
esul an es de ejecu a los p og amas en el en o no, espec o a eje-
cuciones no males po los p opios in é p e es. Los esul ados han sido
sa is ac o ios, ya que el en o no solo añade una pequeña cons an e em-
po al y de memo ia pa a cada ipo de ejecución, un e ec o acep able
conside ando las u ilidades y segu idad que nos o ece.
7.1. T abajo u u o
Una de las me as que inalmen e no pudo cumpli se debido a la al a de
iempo e a la de implemen a es e sis ema de ejecución sob e el juez ¡Acep a
el e o, inco po ando Py hon a la lis a de lenguajes disponibles.
Lo p ime o que necesi a íamos es con inua ealizando p uebas de ali-
dación sob e el en o no, pa a asegu a nos de que las llamadas pe mi idas
inalmen e son necesa ias y su icien es pa a la ejecución de cualquie p og a-
ma en Py hon que que emos pe mi i .
En segundo luga end íamos que abo da la a ea de es ablece la me-
mo ia lími e de cada p oblema. En es e momen o ninguno de los p oblemas
del juez es esoluble en Py hon con los lími es ac uales. Los p oblemas que
no hacen uso excesi o de la memo ia ienen un lími e de 4096 KiB, mien as
que Py hon u iliza al ededo del doble solo pa a inicia se. Una posible so-
lución consis i ía en únicamen e medi la memo ia u ilizada po encima del
consumo base del in é p e e, cosa ya implemen ada en el juez pa a medi la
memo ia usada po Ja a.
Es o no soluciona ía el p oblema de la memo ia, pues en los p oblemas
que sí hacen uso in enso de la memo ia (po ejemplo p oblemas donde nece-
si amos gua da 1 millón de en e os), ¡Acep a el e o asume que cada uno de
ellos a a ocupa 4 by es, po lo que el a ay de 1 millón ocupa ía 4 MiB.
Sin emba go y cómo hemos is o en el Es ado del a e, en Py hon cada en-
e o ocupa 28 by es, el a ay ocupa ía 26.7 MiB y end íamos un MLE. Una
posible solución pa a es os p oblemas es la de asigna al lími e de memo ia
de Py hon supe io , aco de a es e hecho, pa a iguala sus capacidades con
el es o de lenguajes. Es o pod ía se implemen ado encon ando un mul i-
78 Capí ulo 7. Conclusiones
plicado sob e el lími e o iginal que pe mi a que las soluciones e icien es en
memo ia no lo supe en y que las no e icien es ob engan MLE.
Conclusions
Th oughou his wo k we ha e success ully de eloped an execu ion sys-
em o Py hon p og ams, capable o unning hem sa ely agains malicious
code and es ic ing he maximum usable memo y o any gi en alue.
The inal en i onmen is able o un any Py hon p og am, p o iding us
wi h he possibili y o limi ing bo h execu ion ime and maximum memo y,
as well as making he p og am ead om a gi en ile and w i e in o ano he ,
and a hi d ile o pe o m a compa ison be ween i and he p og am ou pu ,
o ob ain he inal e dic .
The memo y limi a ion was inally done using Linux sys em calls. This
is enough as i is he scope o he p ojec , bu i is s ill a limi a ion o bea
in mind.
Rega ding he limi a ion i sel , we need o alk abou i s sho comings.
Fi s o all, he memo y limi a ions a ec sepa a ely he segmen o da a me-
mo y (RLIMIT_DATA) and he s ack o he p og am (RLIMIT_STACK),
while he memo y measu emen ob ains he maximum esiden se size,
which is app oxima ely he sum o bo h. In p og ams ha make in ensi-
e use o bo h da a and he s ack, he memo y-limi a ion sys em does no
in e up hei execu ion un il one o hem su passes he es ablished limi ,
which would heo e ically allow he use wice as much memo y as allowed,
hal on he da a and hal on he s ack. As an example:
Gi en a limi o 100 MiB, he en i onmen limi s he da a memo y o
100 MiB and he s ack memo y o also 100 MiB. The ope a ing sys em
will no in e up he p og am execu ion un il one he he sec ions
g ows o mo e han he limi , allowing a p og am o use 90 MiB o da a
and 90 MiB o s ack, which is way highe han he limi we imposed.
This sho coming only a ec s he execu ion i sel , since he execu ion
p og am ob ains sepa a ely he peak memo y and e u ns he e dic Me-
mo y Limi Exceeded when i is highe han he limi .
Sys em calls es ic ion using he seccomp lib a y is also s ongly de-
penden on a Linux pla o m ha sha es he same calls as he one used
h oughou he p ojec . Fo he es ic ions, he e sion o Py hon is also
e y impo an , since a sligh change in he execu ion o ce ain unc ions
79