LCPQ
/
irpf90
mirror of https://gitlab.com/scemama/irpf90.git
10
0
Fork 0
Code Releases Activity

Fix memory debug and tab

This commit is contained in:
Thomas Applencourt 2017-03-17 11:20:18 -05:00
parent a4a6d7ceaa
commit 3c89b53828
27 changed files with 1369 additions and 1523 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

274
src/build_file.py
View File

@ -36,6 +36,7 @@ irp_id = irpf90_t.irp_id
cwd = os.getcwd()
def dress(f, in_root=False):
#(str,bool) -> str
""" Transfoms the filename into $PWD/IRPF90_temp/f
@ -65,15 +66,13 @@ def create_build_touches(l_irp_m, ninja):
result_ninja = '\n'.join([
"build {target_o}: compile_fortran_{irp_id} {target_F90} | {list_of_modules_irp}",
" short_in = {short_target_F90}",
" short_out = {short_target_o}",
""
" short_in = {short_target_F90}", " short_out = {short_target_o}", ""
])
result_make = '\n'.join([
"{target_o}: {target_F90} | {list_of_modules_irp}",
'\t@printf "F: {short_target_F90} -> {short_target_o}\\n"',
"\t@$(FC) $(FCFLAGS) -c $^ -o $@", ""
'\t@printf "F: {short_target_F90} -> {short_target_o}\\n"',
"\t@$(FC) $(FCFLAGS) -c $^ -o $@", ""
])
result = result_ninja if ninja else result_make
@ -96,15 +95,12 @@ def create_build_archive(l_irp_o, l_usr_o_wo_main, l_ext_o, l_irp_sup_o, ninja=T
list_of_object = ' '.join(l_irp_o + l_usr_o_wo_main + l_ext_o + l_irp_sup_o)
result_ninja = '\n'.join([
"build {lib}: archive_{irp_id} {list_of_object}",
" short_out = {short_lib}",
""])
result_ninja = '\n'.join(
["build {lib}: archive_{irp_id} {list_of_object}", " short_out = {short_lib}", ""])
result_make = '\n'.join([
"{lib}: {list_of_object}",
'\t@printf "Archive: {short_lib}\\n"',
"\t@$(AR) cr $@ $^", ""])
"{lib}: {list_of_object}", '\t@printf "Archive: {short_lib}\\n"', "\t@$(AR) cr $@ $^", ""
])
result = result_ninja if ninja else result_make
return result.format(**locals())
@ -124,8 +120,9 @@ def create_build_link(t, l_irp_m, l_usr_m, l_ext_m, ninja=True):
basename = os.path.basename(filename)
if basename != progname:
from util import logger
logger.info('program-name `{0}` != file-name `{1}` (using file-name for now...)'.format(progname,basename))
from util import logger
logger.info('program-name `{0}` != file-name `{1}` (using file-name for now...)'.format(
progname, basename))
target = dress(filename, in_root=True)
short_target = filename
@ -138,14 +135,13 @@ def create_build_link(t, l_irp_m, l_usr_m, l_ext_m, ninja=True):
result_ninja = '\n'.join([
"build {target}: link_{irp_id} {target_o} {irp_lib} | {list_of_module}",
" short_out = {short_target}",
""])
" short_out = {short_target}", ""
])
result_make = '\n'.join([
"{target}:{target_o} {irp_lib} | {list_of_module}",
'\t@printf "Link: {short_target}\\n"',
"\t@$(FC) $^ $(LIB) -o $@",
""])
"{target}:{target_o} {irp_lib} | {list_of_module}", '\t@printf "Link: {short_target}\\n"',
"\t@$(FC) $^ $(LIB) -o $@", ""
])
result = result_ninja if ninja else result_make
@ -186,10 +182,10 @@ def create_build_compile(t, l_module, l_ext_modfile=[], ninja=True):
# Expensive and stupid. We can create a dict to do the loockup only once
for m in t.needed_modules_usr:
# m is name
for x in l_module:
if m in x.gen_mod and x.filename != t.filename:
needed_modules.append("%s.irp.o" % x.filename)
# m is name
for x in l_module:
if m in x.gen_mod and x.filename != t.filename:
needed_modules.append("%s.irp.o" % x.filename)
from util import uniquify
needed_modules = uniquify(needed_modules)
@ -206,51 +202,47 @@ def create_build_compile(t, l_module, l_ext_modfile=[], ninja=True):
target_module_F90 = dress(short_target_module_F90)
needed_modules_irp += [target_module_o]
list_of_modules = ' '.join(map(dress, needed_modules))
list_of_modules = ' '.join(map(dress, needed_modules))
list_of_modules_irp = ' '.join(map(dress, needed_modules_irp))
inline_include = True
if not inline_include:
#Wrong name, this not work!
#list_of_includes = ' '.join(map(lambda x: dress(x, in_root=True), t.includes))
raise NotImplemented
#Wrong name, this not work!
#list_of_includes = ' '.join(map(lambda x: dress(x, in_root=True), t.includes))
raise NotImplemented
else:
#The include have already by included
list_of_includes = ' '
#The include have already by included
list_of_includes = ' '
l_build = [
"build {target_o}: compile_fortran_{irp_id} {target_F90} | {list_of_includes} {list_of_modules} {list_of_modules_irp}",
" short_in = {short_target_F90}",
" short_out = {short_target}",
""
" short_in = {short_target_F90}", " short_out = {short_target}", ""
]
l_build_make = [
"{target_o}: {target_F90} | {list_of_includes} {list_of_modules} {list_of_modules_irp}",
'\t@printf "F: {short_target_F90} -> {short_target}\\n"',
"\t@$(FC) $(FCFLAGS) -c $^ -o $@", ""
'\t@printf "F: {short_target_F90} -> {short_target}\\n"', "\t@$(FC) $(FCFLAGS) -c $^ -o $@",
""
]
# No need of module when compiling the irp_module.
if t.has_irp_module:
l_build += [
"build {target_module_o}: compile_fortran_{irp_id} {target_module_F90} | {list_of_includes} {list_of_modules} ",
" short_in = {short_target_module_F90}",
" short_out = {short_target_module_o}",
""
" short_in = {short_target_module_F90}", " short_out = {short_target_module_o}", ""
]
l_build_make += [
"{target_module_o}: {target_module_F90} | {list_of_includes} {list_of_modules}",
'\t@printf "F: {short_target_module_F90} -> {short_target_module_o}\\n"',
"\t@$(FC) $(FCFLAGS) -c $^ -o $@", ""
'\t@printf "F: {short_target_module_F90} -> {short_target_module_o}\\n"',
"\t@$(FC) $(FCFLAGS) -c $^ -o $@", ""
]
l_cur = l_build if ninja else l_build_make
return '\n'.join(l_cur).format(**locals())
def create_build_remaining(f,ninja):
def create_build_remaining(f, ninja):
"""
Create the build command for the remaining file f. f is a file name (str).
"""
@ -271,10 +263,10 @@ def create_build_remaining(f,ninja):
if extension.lower() in ['f', 'f90']:
result = ["build {target_o}: compile_fortran_{irp_id} {target_i}"]
result_make = [
'{target_o}: {target_i}',
'\t@printf "F: {short_target_o} -> {short_target_i}\\n"',
"\t@$(FC) $(FCFLAGS) -c $^ -o $@", ""]
result_make = [
'{target_o}: {target_i}', '\t@printf "F: {short_target_o} -> {short_target_i}\\n"',
"\t@$(FC) $(FCFLAGS) -c $^ -o $@", ""
]
elif extension.lower() in ['c']:
result = ["build {target_o}: compile_c_{irp_id} {target_i}"]
@ -283,105 +275,77 @@ def create_build_remaining(f,ninja):
result += [" short_in = {short_target_i}", " short_out = {short_target_o}", ""]
result_final = result if ninja else result_make
result_final = result if ninja else result_make
return '\n'.join(result_final).format(**locals())
def create_makefile(d_flags,d_var,irpf90_flags,ninja=True):
def create_makefile(d_flags, d_var, irpf90_flags, ninja=True):
result = ["IRPF90= irpf90",
"IRPF90FLAGS= %s" % irpf90_flags,
"BUILD_SYSTEM= %s" % ('ninja' if ninja else 'make'),
""]
result = [
"IRPF90= irpf90", "IRPF90FLAGS= %s" % irpf90_flags,
"BUILD_SYSTEM= %s" % ('ninja' if ninja else 'make'), ""
]
# Export all the env variable used by irpf90
result += ['.EXPORT_ALL_VARIABLES:',
'',
'\n'.join("{0} = {1}".format(k, v) for k, v in sorted(d_flags.iteritems())),
'',
'\n'.join("{0} = {1}".format(k, ' '.join(v)) for k, v in sorted(d_var.iteritems())),
'']
result += [
'.EXPORT_ALL_VARIABLES:', '', '\n'.join("{0} = {1}".format(k, v)
for k, v in sorted(d_flags.iteritems())), '',
'\n'.join("{0} = {1}".format(k, ' '.join(v)) for k, v in sorted(d_var.iteritems())), ''
]
result += [ r'# Dark magic below modify with caution!',
r'# "You are Not Expected to Understand This"',
r"# .",
r"# /^\ .",
r'# /\ "V",',
r"# /__\ I O o",
r"# //..\\ I .",
r"# \].`[/ I",
r"# /l\/j\ (] . O",
r"# /. ~~ ,\/I .",
r"# \\L__j^\/I o",
r"# \/--v} I o .",
r"# | | I _________",
r"# | | I c(` ')o",
r"# | l I \. ,/",
r"# _/j L l\_! _//^---^\\_",
r""]
result += [
r'# Dark magic below modify with caution!', r'# "You are Not Expected to Understand This"',
r"# .", r"# /^\ .", r'# /\ "V",',
r"# /__\ I O o", r"# //..\\ I .", r"# \].`[/ I",
r"# /l\/j\ (] . O", r"# /. ~~ ,\/I .", r"# \\L__j^\/I o",
r"# \/--v} I o .", r"# | | I _________", r"# | | I c(` ')o",
r"# | l I \. ,/", r"# _/j L l\_! _//^---^\\_", r""
]
result += ["",
"ifeq ($(BUILD_SYSTEM),ninja)",
"\tBUILD_FILE=IRPF90_temp/build.ninja",
"\tIRPF90FLAGS += -j",
"else ifeq ($(BUILD_SYSTEM),make)",
"\tBUILD_FILE=IRPF90_temp/build.make",
"\tBUILD_SYSTEM += -j",
"else",
"DUMMY:",
"\t$(error 'Wrong BUILD_SYSTEM: $(BUILD_SYSTEM)')",
"endif"]
result += [
"", "ifeq ($(BUILD_SYSTEM),ninja)", "\tBUILD_FILE=IRPF90_temp/build.ninja",
"\tIRPF90FLAGS += -j", "else ifeq ($(BUILD_SYSTEM),make)",
"\tBUILD_FILE=IRPF90_temp/build.make", "\tBUILD_SYSTEM += -j", "else", "DUMMY:",
"\t$(error 'Wrong BUILD_SYSTEM: $(BUILD_SYSTEM)')", "endif"
]
result += ["",
"define run_and_touch",
" $(BUILD_SYSTEM) -C $(dir $(1) ) -f $(notdir $(1) ) $(addprefix $(CURDIR)/, $(2)) && touch $(2)",
"endef",
"",
"EXE := $(shell egrep -ri '^\s*program' *.irp.f | cut -d'.' -f1)",
"",
".PHONY: all",
"",
"all: $(BUILD_FILE)",
"\t$(call run_and_touch, $<, $(EXE))",
"",
".NOTPARALLEL: $(EXE)",
"$(EXE): $(BUILD_FILE)",
"\t$(call run_and_touch, $<, $(EXE))",
"$(BUILD_FILE): $(shell find . -maxdepth 2 -path ./IRPF90_temp -prune -o -name '*.irp.f' -print)",
"\t$(IRPF90) $(IRPF90FLAGS)",
"",
"clean:",
'\trm -f -- $(BUILD_FILE) $(EXE)'
'\t$(shell find IRPF90_temp -type f \\( -name "*.o" -o -name "*.mod" -name "*.a" \\) -delete;)',
"veryclean: clean",
"\trm -rf IRPF90_temp/ IRPF90_man/ irpf90_entities dist tags"]
result += [
"", "define run_and_touch",
" $(BUILD_SYSTEM) -C $(dir $(1) ) -f $(notdir $(1) ) $(addprefix $(CURDIR)/, $(2)) && touch $(2)",
"endef", "", "EXE := $(shell egrep -ri '^\s*program' *.irp.f | cut -d'.' -f1)", "",
".PHONY: all", "", "all: $(BUILD_FILE)", "\t$(call run_and_touch, $<, $(EXE))", "",
".NOTPARALLEL: $(EXE)", "$(EXE): $(BUILD_FILE)", "\t$(call run_and_touch, $<, $(EXE))",
"$(BUILD_FILE): $(shell find . -maxdepth 2 -path ./IRPF90_temp -prune -o -name '*.irp.f' -print)",
"\t$(IRPF90) $(IRPF90FLAGS)", "", "clean:", '\trm -f -- $(BUILD_FILE) $(EXE)'
'\t$(shell find IRPF90_temp -type f \\( -name "*.o" -o -name "*.mod" -name "*.a" \\) -delete;)',
"veryclean: clean", "\trm -rf IRPF90_temp/ IRPF90_man/ irpf90_entities dist tags"
]
import util
data = '%s\n' % '\n'.join(result)
util.lazy_write_file('Makefile',data,conservative=True)
data = '%s\n' % '\n'.join(result)
util.lazy_write_file('Makefile', data, conservative=True)
def create_make_all_clean(l_main):
#
'''Create the ALL and CLEAN target of Makefile
#
'''Create the ALL and CLEAN target of Makefile
Note: Portability doesn't mater. -delete is maybe not posix
but -exec rm {} + is far more ugly!
'''
l_executable =' '.join(dress( t.filename, in_root=True) for t in l_main)
l_executable = ' '.join(dress(t.filename, in_root=True) for t in l_main)
output = [".PHONY : all",
"all: {l_executable}",
"",
".PHONY: clean",
"clean:",
'\tfind . -type f \( -name "*.o" -o -name "*.mod" \) -delete; rm -f {l_executable} --'
""]
output = [
".PHONY : all", "all: {l_executable}", "", ".PHONY: clean", "clean:",
'\tfind . -type f \( -name "*.o" -o -name "*.mod" \) -delete; rm -f {l_executable} --'
""
]
return ['\n'.join(output).format(**locals())]
return [ '\n'.join(output).format(**locals())]
def create_var_and_rule(d_flags, ninja):
@ -392,59 +356,49 @@ def create_var_and_rule(d_flags, ninja):
# Rules
t = [
"rule compile_fortran_{irp_id}",
" command = $FC $FCFLAGS -c $in -o $out",
" description = F : $short_in -> $short_out",
"",
"rule compile_c_{irp_id}",
"rule compile_fortran_{irp_id}", " command = $FC $FCFLAGS -c $in -o $out",
" description = F : $short_in -> $short_out", "", "rule compile_c_{irp_id}",
" command = $CC $CFLAGS -c $in -o $out",
" description = C : $short_in -> $short_out",
"",
"rule compile_cxx_{irp_id}",
" description = C : $short_in -> $short_out", "", "rule compile_cxx_{irp_id}",
" command = $CXX $CXXFLAGS -c $in -o $out",
" description = C++ : $short_in -> $short_out",
"",
"rule archive_{irp_id}",
" command = $AR cr $out $in",
" description = Archive: $short_out",
"",
"rule link_{irp_id}",
" command = $FC $FCFLAGS $in $LIB -o $out",
" description = Link: $short_out",
""
" description = C++ : $short_in -> $short_out", "", "rule archive_{irp_id}",
" command = $AR cr $out $in", " description = Archive: $short_out", "",
"rule link_{irp_id}", " command = $FC $FCFLAGS $in $LIB -o $out",
" description = Link: $short_out", ""
]
output += ['\n'.join(t).format(irp_id=irpf90_t.irp_id, **d_flags)]
return output
# Environment variables
d_default = {
"FC": "gfortran",
"FCFLAGS": "-O2",
"AR": "ar",
"RANLIB": " ranlib",
"CC": "gcc",
"CFLAGS": "-O2",
"CXX": "g++",
"CXXFLAGS": "-O2",
"LIB": ""}
"FC": "gfortran",
"FCFLAGS": "-O2",
"AR": "ar",
"RANLIB": " ranlib",
"CC": "gcc",
"CFLAGS": "-O2",
"CXX": "g++",
"CXXFLAGS": "-O2",
"LIB": ""
}
d_flags = dict()
for k, v in d_default.iteritems():
d_flags[k] = os.environ[k] if k in os.environ else v
d_flags[k] = os.environ[k] if k in os.environ else v
include_dir = ' ' + ' '.join(["-I %s" % (i) for i in command_line.include_dir])
d_var = dict()
for k in ['SRC', 'OBJ']:
d_var[k] = os.environ[k].split() if k in os.environ else []
d_var[k] = os.environ[k].split() if k in os.environ else []
def create_generalmakefile(ninja):
create_makefile(d_flags,d_var, include_dir,ninja)
create_makefile(d_flags, d_var, include_dir, ninja)
def run(d_module, ninja):
#(Dict[str,Module],bool) -> str
@ -485,7 +439,7 @@ def run(d_module, ninja):
l_irp_sup_o = ["irp_touches.irp.o"]
l_irp_sup_s = ["irp_touches.irp.F90"]
if command_line.do_assert:
if command_line.do_debug or command_line.do_assert:
l_irp_sup_o += ["irp_stack.irp.o"]
l_irp_sup_s += ["irp_stack.irp.F90"]
@ -518,13 +472,13 @@ def run(d_module, ninja):
output = create_var_and_rule(d_flags, ninja)
if not ninja:
output += create_make_all_clean(l_mod_main)
output += create_make_all_clean(l_mod_main)
# Create all the .irp.F90 -> .o
for m in l_mod:
output.append(create_build_compile(m, l_mod, l_ext_m, ninja))
output.append(create_build_touches(l_irp_m,ninja))
output.append(create_build_touches(l_irp_m, ninja))
# All the objects. Kind of, only need usr without main for the static library
output.append(create_build_archive(l_irp_o, l_usr_o_wo_main, l_ext_o, l_irp_sup_o, ninja))
@ -533,13 +487,13 @@ def run(d_module, ninja):
output.append(create_build_link(i, l_irp_m, l_usr_m, l_ext_m, ninja))
# Remaining files
for i in l_irp_sup_s[1:]+l_ext_s:
for i in l_irp_sup_s[1:] + l_ext_s:
output.append(create_build_remaining(i, ninja))
filename = os.path.join(irpdir, "build.ninja" if ninja else "build.make")
data = '%s\n' % '\n\n'.join(output)
import util
util.lazy_write_file(filename,data,touch=True)
util.lazy_write_file(filename, data, touch=True)
return

18
src/codelet.py
View File

@ -27,8 +27,9 @@
from command_line import command_line
import irpf90_t
def run():
template = """
template = """
program codelet_%(name)s
implicit none
integer :: i
@ -58,12 +59,11 @@ end
"""
name, NMAX, precondition, filename = command_line.codelet
if precondition is None:
precondition = ""
else:
precondition = "PROVIDE "+precondition
from util import lazy_write_file
lazy_write_file(filename,template%locals())
name, NMAX, precondition, filename = command_line.codelet
if precondition is None:
precondition = ""
else:
precondition = "PROVIDE " + precondition
from util import lazy_write_file
lazy_write_file(filename, template % locals())

322
src/command_line.py
View File

@ -32,125 +32,150 @@ import re
description = "IRPF90 Fortran preprocessor."
options = {}
options['a'] = [ 'assert' , 'Activates ASSERT statements. If absent, remove ASSERT statements.', 0 ]
options['c'] = [ 'codelet' , 'entity:NMAX or entity:precondition:NMAX : Generate a codelet to profile a provider running NMAX times', 1 ]
options['C'] = [ 'coarray' , 'All providers are coarrays', 0 ]
options['d'] = [ 'debug' , 'Activates debug. The name of the current subroutine/function/provider will be printed on the standard output when entering or exiting a routine, as well as the CPU time passed inside the routine.', 0 ]
options['D'] = [ 'define' , 'Defines a variable identified by the IRP_IF statements.', 1 ]
options['g'] = [ 'profile' , 'Activates profiling of the code.', 0 ]
options['h'] = [ 'help' , 'Print this help', 0 ]
options['I'] = [ 'include' , 'Include directory', 1 ]
options['j'] = [ 'ninja' , 'Use Ninja instead of make', 0 ]
options['i'] = [ 'init' , 'Initialize current directory. Creates a default Makefile and the temporary working directories.', 0 ]
options['l'] = [ 'align' , 'Align arrays using compiler directives and sets the $IRP_ALIGN variable. For example, --align=32 aligns all arrays on a 32 byte boundary.', 1 ]
options['m'] = [ 'memory' , 'Print memory allocations/deallocations.', 0 ]
options['n'] = [ 'inline' , '<all|providers|builders> : Force inlining of providers or builders', 1 ]
options['o'] = [ 'checkopt' , 'Shows where optimization may be required', 0 ]
options['p'] = [ 'preprocess' , 'Prints a preprocessed file to standard output. Useful for debugging files containing shell scripts.', 1 ]
options['r'] = [ 'no_directives', 'Ignore all compiler directives !DEC$ and !DIR$', 0 ]
options['s'] = [ 'substitute' , 'Substitute values in do loops for generating specific optimized code.', 1 ]
options['t'] = [ 'touch' , 'Display which entities are touched when touching the variable given as an argument.', 1 ]
options['v'] = [ 'version' , 'Prints version of irpf90', 0 ]
options['w'] = [ 'warnings' , 'Activate Warnings', 0 ]
options['z'] = [ 'openmp' , 'Activate for OpenMP code', 0 ]
options['G'] = [ 'graph' , 'Print the dependecy-graph of the entities (dots format)', 0 ]
options['T'] = [ 'Task' , 'Auto-parallelism ', 0 ]
options['a'] = ['assert', 'Activates ASSERT statements. If absent, remove ASSERT statements.', 0]
options['c'] = [
'codelet',
'entity:NMAX or entity:precondition:NMAX : Generate a codelet to profile a provider running NMAX times',
1
]
options['C'] = ['coarray', 'All providers are coarrays', 0]
options['d'] = [
'debug',
'Activates debug. The name of the current subroutine/function/provider will be printed on the standard output when entering or exiting a routine, as well as the CPU time passed inside the routine.',
0
]
options['D'] = ['define', 'Defines a variable identified by the IRP_IF statements.', 1]
options['g'] = ['profile', 'Activates profiling of the code.', 0]
options['h'] = ['help', 'Print this help', 0]
options['I'] = ['include', 'Include directory', 1]
options['j'] = ['ninja', 'Use Ninja instead of make', 0]
options['i'] = [
'init',
'Initialize current directory. Creates a default Makefile and the temporary working directories.',
0
]
options['l'] = [
'align',
'Align arrays using compiler directives and sets the $IRP_ALIGN variable. For example, --align=32 aligns all arrays on a 32 byte boundary.',
1
]
options['m'] = ['memory', 'Print memory allocations/deallocations.', 0]
options['n'] = ['inline', '<all|providers|builders> : Force inlining of providers or builders', 1]
options['o'] = ['checkopt', 'Shows where optimization may be required', 0]
options['p'] = [
'preprocess',
'Prints a preprocessed file to standard output. Useful for debugging files containing shell scripts.',
1
]
options['r'] = ['no_directives', 'Ignore all compiler directives !DEC$ and !DIR$', 0]
options['s'] = [
'substitute', 'Substitute values in do loops for generating specific optimized code.', 1
]
options['t'] = [
'touch', 'Display which entities are touched when touching the variable given as an argument.',
1
]
options['v'] = ['version', 'Prints version of irpf90', 0]
options['w'] = ['warnings', 'Activate Warnings', 0]
options['z'] = ['openmp', 'Activate for OpenMP code', 0]
options['G'] = ['graph', 'Print the dependecy-graph of the entities (dots format)', 0]
options['T'] = ['Task', 'Auto-parallelism ', 0]
class CommandLine(object):
def __init__(self):
global options
self._opts = None
self.argv = list(sys.argv)
self.executable_name = self.argv[0]
def __init__(self):
global options
self._opts = None
self.argv = list(sys.argv)
self.executable_name = self.argv[0]
@irpy.lazy_property
def defined(self):
return [a for o, a in self.opts if o in ["-D", '--' + options['D'][0]]]
@irpy.lazy_property
def defined(self):
return [ a for o,a in self.opts if o in [ "-D", '--'+options['D'][0] ] ]
@irpy.lazy_property
def graph(self):
return next((a.split() for o, a in self.opts if o in ["-G", '--' + options['G'][0]]), [])
@irpy.lazy_property
def graph(self):
return next((a.split() for o,a in self.opts if o in ["-G", '--'+options['G'][0] ]),[])
@irpy.lazy_property
def include_dir(self):
l = []
for o,a in self.opts:
if o in [ "-I", '--'+options['I'][0] ]:
if len(a) < 1:
print "Error: -I option needs a directory"
if a[-1] != '/':
a = a+'/'
l.append(a)
return l
@irpy.lazy_property
def inline(self):
return next( (a for o,a in self.opts if o in [ "-n", '--'+options['n'][0] ]),'')
@irpy.lazy_property
def include_dir(self):
l = []
for o, a in self.opts:
if o in ["-I", '--' + options['I'][0]]:
if len(a) < 1:
print "Error: -I option needs a directory"
if a[-1] != '/':
a = a + '/'
l.append(a)
return l
@irpy.lazy_property
def substituted(self):
self._substituted = {}
for o,a in self.opts:
if o in [ "-s", '--'+options['s'][0] ]:
k, v = a.split(':')
v_re = re.compile(r"(\W)(%s)(\W.*$|$)"%k.strip())
self._substituted[k] = [v, v_re]
return self._substituted
@irpy.lazy_property
def inline(self):
return next((a for o, a in self.opts if o in ["-n", '--' + options['n'][0]]), '')
@irpy.lazy_property
def codelet(self):
for o,a in self.opts:
if o in [ "-c", '--'+options['c'][0] ]:
buffer = a.split(':')
filename = 'codelet_'+buffer[0]+'.irp.f'
if len(buffer) == 2:
return [buffer[0], int(buffer[1]), None, filename]
elif len(buffer) == 3:
return [buffer[0], int(buffer[2]), buffer[1], filename]
else:
print """
@irpy.lazy_property
def substituted(self):
self._substituted = {}
for o, a in self.opts:
if o in ["-s", '--' + options['s'][0]]:
k, v = a.split(':')
v_re = re.compile(r"(\W)(%s)(\W.*$|$)" % k.strip())
self._substituted[k] = [v, v_re]
return self._substituted
@irpy.lazy_property
def codelet(self):
for o, a in self.opts:
if o in ["-c", '--' + options['c'][0]]:
buffer = a.split(':')
filename = 'codelet_' + buffer[0] + '.irp.f'
if len(buffer) == 2:
return [buffer[0], int(buffer[1]), None, filename]
elif len(buffer) == 3:
return [buffer[0], int(buffer[2]), buffer[1], filename]
else:
print """
Error in codelet definition. Use:
--codelet=provider:NMAX
or
--codelet=provider:precondition:NMAX
"""
sys.exit(1)
sys.exit(1)
@irpy.lazy_property
def preprocessed(self):
return [a for o,a in self.ops if o in [ "-p", '--'+options['p'][0] ] ]
@irpy.lazy_property
def preprocessed(self):
return [a for o, a in self.ops if o in ["-p", '--' + options['p'][0]]]
@irpy.lazy_property
def touched(self):
return [a for o,a in self.ops if o in [ "-t", '--'+options['t'][0] ] ]
@irpy.lazy_property
def touched(self):
return [a for o, a in self.ops if o in ["-t", '--' + options['t'][0]]]
@irpy.lazy_property
def align(self):
return next( (a for o,a in self.opts if o in [ "-l", '--'+options['l'][0] ]),'1')
@irpy.lazy_property
def align(self):
return next((a for o, a in self.opts if o in ["-l", '--' + options['l'][0]]), '1')
@irpy.lazy_property
def coarray(self):
return any(o for o,a in self.opts if o in [ "-C", '--'+options['C'][0] ])
@irpy.lazy_property
def coarray(self):
return any(o for o, a in self.opts if o in ["-C", '--' + options['C'][0]])
@irpy.lazy_property
def warnings(self):
return any(o for o,a in self.opts if o in [ "-W", '--'+options['W'][0] ])
@irpy.lazy_property
def warnings(self):
return any(o for o, a in self.opts if o in ["-W", '--' + options['W'][0]])
@irpy.lazy_property
def openmp(self):
return any(o for o,a in self.opts if o in [ "-z", '--'+options['z'][0] ])
@irpy.lazy_property
def openmp(self):
return any(o for o, a in self.opts if o in ["-z", '--' + options['z'][0]])
@irpy.lazy_property
def ninja(self):
return any(o for o,a in self.opts if o in [ "-j", '--'+options['j'][0] ])
@irpy.lazy_property
def ninja(self):
return any(o for o, a in self.opts if o in ["-j", '--' + options['j'][0]])
@irpy.lazy_property
def directives(self):
return not(any(o for o,a in self.opts if o in [ "-r", '--'+options['r'][0] ]))
@irpy.lazy_property
def directives(self):
return not (any(o for o, a in self.opts if o in ["-r", '--' + options['r'][0]]))
def usage(self):
t = """
def usage(self):
t = """
$EXE - $DESCR
Usage:
@ -158,37 +183,38 @@ Usage:
Options:
"""
t = t.replace("$EXE",self.executable_name)
t = t.replace("$DESCR",description)
print t
print_options()
print ""
print "Version : ", version
print ""
t = t.replace("$EXE", self.executable_name)
t = t.replace("$DESCR", description)
print t
print_options()
print ""
print "Version : ", version
print ""
def opts(self):
if self._opts is None:
optlist = ["",[]]
for o in options:
b = [o]+options[o]
if b[3] == 1:
b[0] = b[0]+":"
b[1] = b[1]+"="
optlist[0] += b[0]
optlist[1] += [b[1]]
try:
self._opts, args = getopt.getopt(self.argv[1:], optlist[0], optlist[1])
except getopt.GetoptError, err:
# print help information and exit:
self.usage()
print str(err) # will print something like "option -a not recognized"
sys.exit(2)
return self._opts
opts = property(fget=opts)
t = """
def opts(self):
if self._opts is None:
optlist = ["", []]
for o in options:
b = [o] + options[o]
if b[3] == 1:
b[0] = b[0] + ":"
b[1] = b[1] + "="
optlist[0] += b[0]
optlist[1] += [b[1]]
try:
self._opts, args = getopt.getopt(self.argv[1:], optlist[0], optlist[1])
except getopt.GetoptError, err:
# print help information and exit:
self.usage()
print str(err) # will print something like "option -a not recognized"
sys.exit(2)
return self._opts
opts = property(fget=opts)
t = """
def do_$LONG(self):
if '_do_$LONG' not in self.__dict__:
self._do_$LONG = False
@ -199,13 +225,14 @@ def do_$LONG(self):
return self._do_$LONG
do_$LONG = property(fget=do_$LONG)
"""
for short in options:
long = options[short][0]
exec t.replace("$LONG",long).replace("$SHORT",short) #in locals()
@irpy.lazy_property
def do_run(self):
return not(any( (self.do_version, self.do_help, self.do_preprocess, self.do_touch, self.do_init)))
for short in options:
long = options[short][0]
exec t.replace("$LONG", long).replace("$SHORT", short) #in locals()
@irpy.lazy_property
def do_run(self):
return not (any(
(self.do_version, self.do_help, self.do_preprocess, self.do_touch, self.do_init)))
# @irpy.lazy_property
# def do_Task(self):
@ -213,17 +240,20 @@ do_$LONG = property(fget=do_$LONG)
command_line = CommandLine()
def print_options():
keys = options.keys()
keys.sort()
import subprocess
for k in keys:
description = options[k][1]
p1 = subprocess.Popen(["fold", "-s", "-w", "40"],stdout=subprocess.PIPE,stdin=subprocess.PIPE)
description = p1.communicate(description)[0]
description = description.replace('\n','\n'.ljust(27))
print ("-%s, --%s"%(k,options[k][0])).ljust(25), description+'\n'
print "\n"
keys = options.keys()
keys.sort()
import subprocess
for k in keys:
description = options[k][1]
p1 = subprocess.Popen(
["fold", "-s", "-w", "40"], stdout=subprocess.PIPE, stdin=subprocess.PIPE)
description = p1.communicate(description)[0]
description = description.replace('\n', '\n'.ljust(27))
print("-%s, --%s" % (k, options[k][0])).ljust(25), description + '\n'
print "\n"
if __name__ == '__main__':
print_options()
print_options()

10
src/create_man.py
View File

@ -27,9 +27,10 @@
from entity import Entity
from routine import Routine
from irpf90_t import mandir
from util import parmap, build_dim,lazy_write_file
from util import parmap, build_dim, lazy_write_file
import os
def do_print_short(entity):
assert type(entity) == Entity
str_ = "{0:<35} : {1:<30} :: {2:<25} {3}".format(entity.prototype.filename[0],
@ -107,7 +108,6 @@ def do_print(entity, d_entity):
lazy_write_file("%s%s.l" % (mandir, name), '%s\n' % str_)
######################################################################
def do_print_subroutines(sub):
assert type(sub) == Routine
@ -164,11 +164,11 @@ def run(d_entity, d_routine):
l_subs = d_routine.values()
l_data_to_write = [("%s.l" % os.path.join(mandir, s.name), do_print_subroutines(s)) for s in l_subs]
l_data_to_write = [("%s.l" % os.path.join(mandir, s.name), do_print_subroutines(s))
for s in l_subs]
def worker(l):
filename, text = l
filename, text = l
lazy_write_file(filename, text)
parmap(worker, l_data_to_write)

41
src/cython_setup.py
View File

@ -1,41 +0,0 @@
#!/usr/bin/env python
# IRPF90 is a Fortran90 preprocessor written in Python for programming using
# the Implicit Reference to Parameters (IRP) method.
# Copyright (C) 2009 Anthony SCEMAMA
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License along
# with this program; if not, write to the Free Software Foundation, Inc.,
# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
#
# Anthony Scemama
# LCPQ - IRSAMC - CNRS
# Universite Paul Sabatier
# 118, route de Narbonne
# 31062 Toulouse Cedex 4
# scemama@irsamc.ups-tlse.fr
from distutils.core import setup
from distutils.extension import Extension
from Cython.Distutils import build_ext
import os
to_remove = """__init__.py cython_setup.py version.py command_line.py""".split()
ext_modules = []
for f in os.listdir('.') if f.emswith(".py") and not f in to_remove:
module = f.split('.')[0]
ext_modules.append(Extension(module,list(f)))
setup(name = 'IRPF90 extensions',
cmdclass = {'build_ext': build_ext},
ext_modules = ext_modules)

86
src/entity.py
View File

@ -30,6 +30,7 @@ from command_line import command_line
import sys
from lib.manager import irpy
class Entity(object):
'''All lines between BEGIN_PROVIDER and END_PROVIDER included
@ -163,26 +164,31 @@ class Entity(object):
def io_er(self):
if not self.is_main:
result = []
from util import mangled
from util import ashes_env
from util import ashes_env
name = self.name
d_template= {'name':name,
'fmodule':self.fmodule,
'same_as' : self.same_as,
'do_debug':command_line.do_debug,
'children':mangled(self.needs,self.d_entity),
'group_entity': [{'name':n,'dim':build_dim(self.cm_d_variable[n].dim,colons=True)} for n in self.l_name]}
d_template = {
'name': name,
'fmodule': self.fmodule,
'same_as': self.same_as,
'do_debug': command_line.do_debug,
'children': mangled(self.needs, self.d_entity),
'group_entity': [{
'name': n,
'dim': build_dim(
self.cm_d_variable[n].dim, colons=True)
} for n in self.l_name]
}
return ashes_env('io.f90',d_template).split('\n')
return ashes_env('io.f90', d_template).split('\n')
def reader(self):
return io.er.split('TOKEN_SPLIT')[0]
return io.er.split('TOKEN_SPLIT')[0]
def writer(self):
return io.er.split('TOKEN_SPLIT')[1]
return io.er.split('TOKEN_SPLIT')[1]
@irpy.lazy_property_mutable
def is_read(self):
@ -275,8 +281,8 @@ class Entity(object):
# ~ # ~ # ~
@irpy.lazy_property
def is_protected(self):
return self.text[0].lower.startswith('begin_provider_immu')
return self.text[0].lower.startswith('begin_provider_immu')
@irpy.lazy_property
def type(self):
# () -> str
@ -303,9 +309,11 @@ class Entity(object):
'name': self.name,
'type': self.type,
'main': self.is_main,
'dim': build_dim(self.dim,colons=True),
'protected': '\n'.join(self.allocater+self.builder) if self.is_protected else False}
return d_template
'dim': build_dim(
self.dim, colons=True),
'protected': '\n'.join(self.allocater + self.builder) if self.is_protected else False
}
return d_template
############################################################
@irpy.lazy_property
@ -340,8 +348,11 @@ class Entity(object):
return {
'name': self.name,
'l_module': [n for n in build_use(self.parents + [self.name], self.d_entity,use=False)],
'l_ancestor': [n for n in mangled(self.parents, self.d_entity)]}
'l_module':
[n for n in build_use(
self.parents + [self.name], self.d_entity, use=False)],
'l_ancestor': [n for n in mangled(self.parents, self.d_entity)]
}
##########################################################
@ -374,11 +385,13 @@ class Entity(object):
from util import mangled
import util
import util
name = self.name
l_module = [x for x in build_use([self.name] + self.to_provide, self.d_entity,use=False)]
l_module = [x for x in build_use([self.name] + self.to_provide, self.d_entity, use=False)]
l_children = [x for x in mangled(self.to_provide, self.d_entity)]
l_entity = [self.d_entity[n] for n in self.l_name]
l = ashes_env.render('provider.f90', {
'name': name,
'l_module': l_module,
@ -386,40 +399,40 @@ class Entity(object):
'do_debug': command_line.do_debug,
'do_openmp': command_line.do_openmp,
'do_task': command_line.do_Task,
'do_corray': command_line.do_coarray,
'dim': ','.join(self.dim),
'do_corray': command_line.do_coarray,
'dim': ','.join(self.dim),
'l_entity': [{
'name': i.name,
'dim': ','.join(i.dim)
} for i in l_entity]
})
return [i for i in l.split('\n') if i.strip()]
@irpy.lazy_property
def allocater(self):
if not self.is_main:
return []
from util import mangled
import util
name = self.name
l_module = [x for x in build_use([self.name] + self.to_provide, self.d_entity,use=False)]
l_module = [x for x in build_use([self.name] + self.to_provide, self.d_entity, use=False)]
if self.is_protected:
l_module.remove(self.fmodule)
l_module.remove(self.fmodule)
l_dim = [{'name': name, 'rank': i + 1, 'value': dimsize(k)} for i, k in enumerate(self.dim)]
l = ashes_env.render('allocater.f90', {
'name': name,
'l_module': l_module,
'do_debug': command_line.do_debug,
'do_corray': command_line.do_coarray,
'do_memory': command_line.do_memory,
'dim': ','.join(self.dim),
'l_dim': l_dim
})
return [i for i in l.split('\n') if i.strip()]
##########################################################
##########################################################
@irpy.lazy_property
def builder(self):
if not self.is_main:
@ -458,7 +471,6 @@ class Entity(object):
text += map(lambda x: ([], Simple_line(line.i, x, line.filename)),
build_call_provide(vars, self.d_entity))
# ~#~#~#~#~#
# Create the subroutine.
# ~#~#~#~#~#
@ -470,11 +482,11 @@ class Entity(object):
# Add the use statement
result += ["subroutine bld_%s" % (self.name)]
l_use = build_use([self.name] + self.needs, self.d_entity,use=False)
if self.is_protected:
l_use.remove(self.fmodule)
l_use = build_use([self.name] + self.needs, self.d_entity, use=False)
if self.is_protected:
l_use.remove(self.fmodule)
result += ['USE %s'%n for n in l_use]
result += ['USE %s' % n for n in l_use]
import parsed_text
# Move the variable to top, and add the text

260
src/irp_stack.py
View File

@ -1,260 +0,0 @@
#!/usr/bin/env python
# IRPF90 is a Fortran90 preprocessor written in Python for programming using
# the Implicit Reference to Parameters (IRP) method.
# Copyright (C) 2009 Anthony SCEMAMA
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License along
# with this program; if not, write to the Free Software Foundation, Inc.,
# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
#
# Anthony Scemama
# LCPQ - IRSAMC - CNRS
# Universite Paul Sabatier
# 118, route de Narbonne
# 31062 Toulouse Cedex 4
# scemama@irsamc.ups-tlse.fr
import util
from command_line import command_line
do_assert = command_line.do_assert
do_debug = command_line.do_debug
do_openmp = command_line.do_openmp
do_memory = command_line.do_memory
import irpf90_t
FILENAME = irpf90_t.irpdir+"irp_stack.irp.F90"
def create():
txt = """
module irp_stack_mod
integer, parameter :: STACKMAX=1000
character*(128),allocatable :: irp_stack(:,:)
double precision,allocatable :: irp_cpu(:,:)
integer,allocatable :: stack_index(:)
logical :: alloc = .False.
integer :: nthread
character*(128) :: white = ''
end module
subroutine irp_enter(irp_where)
use irp_stack_mod
integer :: ithread
character*(*) :: irp_where
"""
if not do_openmp:
txt += """
ithread = 0
"""
else:
txt += """
integer, external :: omp_get_thread_num
integer, external :: omp_get_num_threads
ithread = omp_get_thread_num()
"""
txt += "$1"
if do_memory:
txt+="""
if (.not.alloc) then
"""
if do_openmp:
txt += """
!$OMP PARALLEL
!$OMP SINGLE
nthread = omp_get_num_threads()
!$OMP END SINGLE
!$OMP END PARALLEL
"""
else:
txt += """
nthread = 1
"""
txt += """
print *, 'Allocating irp_stack(',STACKMAX,',',0:nthread,')'
print *, 'Allocating irp_cpu(',STACKMAX,',',0:nthread,')'
print *, 'Allocating stack_index(',0:nthread,')'
endif"""
txt +="""
$2
end subroutine
subroutine irp_enter_f(irp_where)
use irp_stack_mod
integer :: ithread
character*(*) :: irp_where
"""
if do_openmp:
txt += """
integer, external :: omp_get_thread_num
integer, external :: omp_get_num_threads
ithread = omp_get_thread_num()
"""
else:
txt += """
ithread = 0
"""
txt += """
$1
"""
if do_memory:
txt+="""
if (.not.alloc) then
"""
if do_openmp:
txt += """
!$OMP PARALLEL
!$OMP SINGLE
nthread = omp_get_num_threads()
!$OMP END SINGLE
!$OMP END PARALLEL
"""
else:
txt += """
nthread = 1
"""
txt +="""
print *, 'Allocating irp_stack(',STACKMAX,',',0:nthread,')'
print *, 'Allocating irp_cpu(',STACKMAX,',',0:nthread,')'
print *, 'Allocating stack_index(',0:nthread,')'
endif
"""
txt += """
$2
end subroutine
subroutine irp_leave (irp_where)
use irp_stack_mod
character*(*) :: irp_where
integer :: ithread
double precision :: cpu
"""
if do_openmp:
txt += """
integer, external :: omp_get_thread_num
ithread = omp_get_thread_num()
"""
else:
txt += """
ithread = 0
"""
txt += """
$3
$4
end subroutine
"""
# $1
if do_assert or do_debug:
s = """
if (.not.alloc) then
"""
if do_openmp:
s += """
!$OMP PARALLEL
!$OMP SINGLE
nthread = omp_get_num_threads()
!$OMP END SINGLE
!$OMP END PARALLEL
!$OMP CRITICAL
if (.not.alloc) then
allocate(irp_stack(0:STACKMAX,0:nthread))
allocate(irp_cpu(0:STACKMAX,0:nthread))
allocate(stack_index(0:nthread))
stack_index = 0
alloc = .True.
endif
!$OMP END CRITICAL
endif
stack_index(ithread) = min(stack_index(ithread)+1,STACKMAX)
irp_stack(stack_index(ithread),ithread) = irp_where"""
else:
s += """
nthread = 1
if (.not.alloc) then
allocate(irp_stack(0:STACKMAX,1))
allocate(irp_cpu(0:STACKMAX,1))
allocate(stack_index(2))
stack_index = 0
alloc = .True.
endif
endif
stack_index(1) = min(stack_index(1)+1,STACKMAX)
irp_stack(stack_index(1),1) = irp_where"""
if do_memory:
txt+="""
print *, 'Allocating irp_stack(',STACKMAX,','0:nthread,')'
print *, 'Allocating irp_cpu(',STACKMAX,','0:nthread,')'
print *, 'Allocating stack_index(',0:nthread,')'"""
else:
s = ""
txt = txt.replace("$1",s)
# $2
if do_debug:
txt = txt.replace("$2","""
print *, ithread, ':', white(1:stack_index(ithread))//'-> ', trim(irp_where)
call cpu_time(irp_cpu(stack_index(ithread),ithread))""")
else:
txt = txt.replace("$2","")
# $3
if do_debug:
txt = txt.replace("$3","""
call cpu_time(cpu)
print *, ithread, ':', white(1:stack_index(ithread))//'<- ', &
trim(irp_stack(stack_index(ithread),ithread)), &
cpu-irp_cpu(stack_index(ithread),ithread)""")
else:
txt = txt.replace("$3","")
# $4
if do_debug or do_assert:
txt = txt.replace("$4","""
stack_index(ithread) = max(0,stack_index(ithread)-1)""")
else:
txt = txt.replace("$4","")
txt += """
subroutine irp_trace
use irp_stack_mod
integer :: ithread
integer :: i
"""
if do_openmp:
txt += """
!$ integer, external :: omp_get_thread_num
!$ ithread = omp_get_thread_num()
"""
else:
txt += """
ithread = 0
"""
txt += """
if (.not.alloc) return
print *, 'Stack trace: ', ithread
print *, '-------------------------'
do i=1,stack_index(ithread)
print *, trim(irp_stack(i,ithread))
enddo
print *, '-------------------------'
end subroutine
"""
util.lazy_write_file(FILENAME,txt)

139
src/irpf90.py
View File

@ -35,125 +35,120 @@ except:
from command_line import command_line
from irpy_files import Irpy_comm_world
def main():
vim.install()
if command_line.do_help:
command_line.usage()
return
return
if command_line.do_version:
from version import version
print version
return
return
if command_line.do_init:
from build_file import create_generalmakefile
create_generalmakefile(command_line.do_ninja)
return
from build_file import create_generalmakefile
create_generalmakefile(command_line.do_ninja)
return
comm_world = Irpy_comm_world()
if command_line.do_graph:
# Create a dot reprenstion of the dependency graph.
# Merge inside a subgraph the Entity provided together
# Create a dot reprenstion of the dependency graph.
# Merge inside a subgraph the Entity provided together
def print_full_diagram(l_entity):
def print_full_diagram(l_entity):
l_entity_not_leaf= [e for e in l_entity if e.needs]
print 'digraph Full { '
for e in l_entity_not_leaf:
print ' %s -> { %s } ' % (e.name, ' '.join(e.needs))
print '}'
l_entity_not_leaf = [e for e in l_entity if e.needs]
print 'digraph Full { '
for e in l_entity_not_leaf:
print ' %s -> { %s } ' % (e.name, ' '.join(e.needs))
print '}'
def print_subgraph(l_tuple,name,color):
for i,s in enumerate(l_tuple):
print ' subgraph cluster_%s_%s {' % (name,i)
def print_subgraph(l_tuple, name, color):
for i, s in enumerate(l_tuple):
print ' subgraph cluster_%s_%s {' % (name, i)
print ' %s ' % ' '.join(s)
print ' color = %s ' % color
print ' }'
comm_world.t_filename_parsed_text # Initialize entity need. Dirty I know.
print_full_diagram(comm_world.d_entity.values())
comm_world.t_filename_parsed_text # Initialize entity need. Dirty I know.
print_full_diagram(comm_world.d_entity.values())
print 'digraph Compact { '
print ' graph [ordering="out" splines=true overlap=false];'
l_main_usr = set([entity for entity in comm_world.d_entity.values() if entity.is_main])
l_main_usr = set([entity for entity in comm_world.d_entity.values() if entity.is_main])
l_main_head_usr = set([entity for entity in l_main_usr if entity.l_others_name])
l_set_main_head_name = [ set(e.l_name) for e in l_main_head_usr]
l_set_main_head_name = [set(e.l_name) for e in l_main_head_usr]
print_subgraph(l_set_main_head_name,'usr',color='blue')
print_subgraph(l_set_main_head_name, 'usr', color='blue')
from util import l_dummy_entity
from util import l_dummy_entity
l_set_dummy_name= l_dummy_entity(comm_world.d_entity)
print_subgraph(l_set_dummy_name,'dummy',color='red')
l_set_dummy_name = l_dummy_entity(comm_world.d_entity)
print_subgraph(l_set_dummy_name, 'dummy', color='red')
#~=~=~=~=
# Create List Node Uniq
#~=~=~=~=
#~=~=~=~=
from util import split_l_set, flatten
l_main_dummy_name, s_exculde_dummy_name = split_l_set(l_set_dummy_name)
l_name_dummy_name_flatten = flatten(l_set_dummy_name)
from util import split_l_set, flatten
l_main_dummy_name, s_exculde_dummy_name = split_l_set(l_set_dummy_name)
l_name_dummy_name_flatten = flatten(l_set_dummy_name)
l_main_head_dummy = set([comm_world.d_entity[name] for name in l_name_dummy_name_flatten])
s_exculde_dummy = set([comm_world.d_entity[name] for name in s_exculde_dummy_name])
l_node_uniq = (l_main_usr | l_main_head_dummy) - s_exculde_dummy
#~=~=~=~=
# Create All edge
#~=~=~=~=
# We need to remove the spurious edge caused by the the dummy multiples providers
d_need = dict()
for e in l_node_uniq:
d_need[e.name] = set(e.needs)
s_exculde_dummy = set([comm_world.d_entity[name] for name in s_exculde_dummy_name])
l_node_uniq = (l_main_usr | l_main_head_dummy) - s_exculde_dummy
#~=~=~=~=
# Create All edge
#~=~=~=~=
# Draw the eddge
# If a arrow if arriving into Multipliple provider and if it is bold this mean it use all the entity inside it.
# We need to remove the spurious edge caused by the the dummy multiples providers
d_need = dict()
for e in l_node_uniq:
d_need[e.name] = set(e.needs)
#~=~=~=~=
# Create All edge
#~=~=~=~=
# Draw the eddge
# If a arrow if arriving into Multipliple provider and if it is bold this mean it use all the entity inside it.
from util import uniquify
l_set_multiple = uniquify(l_set_dummy_name + l_set_main_head_name)
l_name_usr = [e.name for e in l_main_head_usr]
for source,l_target in d_need.items():
l_name_usr = [e.name for e in l_main_head_usr]
for source, l_target in d_need.items():
if source in l_name_usr:
color = 'blue'
elif source in l_name_dummy_name_flatten:
color = 'red'
else:
color = 'black'
if source in l_name_usr:
color = 'blue'
elif source in l_name_dummy_name_flatten:
color = 'red'
else:
color = 'black'
for s in l_set_multiple:
if s.issubset(l_target):
print ' %s -> %s [color="%s", penwidth=2]' %(source,sorted(s).pop(), color)
l_target = l_target - s
for s in l_set_multiple:
if s.issubset(l_target):
print ' %s -> %s [color="%s", penwidth=2]' % (source, sorted(s).pop(), color)
l_target = l_target - s
if l_target:
print ' %s -> { %s } [color="%s"]'% (source,' '.join(l_target), color)
print ' }'
return
if l_target:
print ' %s -> { %s } [color="%s"]' % (source, ' '.join(l_target), color)
print ' }'
return
if command_line.do_preprocess:
for filename, text in comm_world.preprocessed_text:
if filename in command_line.preprocessed:
for line in text:
print line.text
return
if filename in command_line.preprocessed:
for line in text:
print line.text
return
if command_line.do_touch:
for var in command_line.touched:
@ -163,7 +158,7 @@ def main():
print "Touching %s invalidates the following entities:" % var
for x in sorted(d_entity[var].parents):
print "- %s" % (x, )
return
return
if command_line.do_codelet:
import profile
@ -176,16 +171,20 @@ def main():
comm_world.create_buildfile(command_line.do_ninja)
comm_world.write_modules()
comm_world.create_touches()
comm_world.create_man()
if command_line.do_debug or command_line.do_assert:
comm_world.create_stack()
if command_line.do_profile:
import profile
profile.run(comm_world.d_entity)
if command_line.do_openmp:
comm_world.create_lock()
comm_world.create_lock()
if __name__ == '__main__':
main()

414
src/irpf90_indent.py
View File

@ -24,249 +24,269 @@
# 31062 Toulouse Cedex 4
# scemama@irsamc.ups-tlse.fr
import sys
import re
LENMAX = 70
tabn = 2
tab = " "*tabn
tab = " " * tabn
class Grep(object):
re_begin_program = re.compile(r"^\s*program\s",flags=re.I)
def begin_program(self,string):
return re.match(self.re_begin_program,string) is not None
re_begin_program = re.compile(r"^\s*program\s", flags=re.I)
re_end_program = re.compile(r"\s*(end\s*!?$|end\s*program)",flags=re.I)
def end_program(self,string):
return re.match(self.re_end_program,string) is not None
def begin_program(self, string):
return re.match(self.re_begin_program, string) is not None
re_begin_subroutine = re.compile(r"^\s*(recursive)?\s*subroutine\s",flags=re.I)
def begin_subroutine(self,string):
return re.match(self.re_begin_subroutine,string) is not None
re_end_program = re.compile(r"\s*(end\s*!?$|end\s*program)", flags=re.I)
re_end_subroutine = re.compile(r"\s*(end\s*!?$|end\s*subroutine)",flags=re.I)
def end_subroutine(self,string):
return re.match(self.re_end_subroutine,string) is not None
def end_program(self, string):
return re.match(self.re_end_program, string) is not None
re_begin_function = re.compile(r"^.*function\s+.*\(",flags=re.I)
def begin_function(self,string):
return re.match(self.re_begin_function,string) is not None
re_begin_subroutine = re.compile(r"^\s*(recursive)?\s*subroutine\s", flags=re.I)
re_end_function = re.compile(r"\s*(end\s*!?$|end\s*function)",flags=re.I)
def end_function(self,string):
return re.match(self.re_end_function,string) is not None
def begin_subroutine(self, string):
return re.match(self.re_begin_subroutine, string) is not None
re_begin_provider = re.compile(r"^\s*&?begin_provider\s",flags=re.I)
def begin_provider(self,string):
return re.match(self.re_begin_provider,string) is not None
re_end_subroutine = re.compile(r"\s*(end\s*!?$|end\s*subroutine)", flags=re.I)
re_end_provider = re.compile(r"^\s*end_provider\s*(!.*)?$", flags=re.I)
def end_provider(self,string):
return re.match(self.re_end_provider,string) is not None
def end_subroutine(self, string):
return re.match(self.re_end_subroutine, string) is not None
re_begin_do = re.compile(r"^\s*do\s+",flags=re.I)
def begin_do(self,string):
return re.match(self.re_begin_do,string) is not None
re_begin_function = re.compile(r"^.*function\s+.*\(", flags=re.I)
re_end_do = re.compile(r"^\s*end\s*do\s*(!.*)?$",flags=re.I)
def end_do(self,string):
return re.match(self.re_end_do,string) is not None
def begin_function(self, string):
return re.match(self.re_begin_function, string) is not None
re_begin_if = re.compile(r"^\s*if(\(|\s+).*(&|then)\s*(!.*)?$",flags=re.I)
def begin_if(self,string):
return re.match(self.re_begin_if,string) is not None
re_end_function = re.compile(r"\s*(end\s*!?$|end\s*function)", flags=re.I)
re_else = re.compile(r"^\s*else",flags=re.I)
def xelse(self,string):
return re.match(self.re_else,string) is not None
def end_function(self, string):
return re.match(self.re_end_function, string) is not None
re_end_if = re.compile(r"^\s*end\s*if\s*(!.*)?$",flags=re.I)
def end_if(self,string):
return re.match(self.re_end_if,string) is not None
re_begin_provider = re.compile(r"^\s*&?begin_provider\s", flags=re.I)
re_begin_select = re.compile(r"^\s*select\s*case",flags=re.I)
def begin_select(self,string):
return re.match(self.re_begin_select,string) is not None
def begin_provider(self, string):
return re.match(self.re_begin_provider, string) is not None
re_case = re.compile(r"^\s*case\s*\(",flags=re.I)
def case(self,string):
return re.match(self.re_case,string) is not None
re_end_provider = re.compile(r"^\s*end_provider\s*(!.*)?$", flags=re.I)
re_end_select = re.compile(r"^\s*end\s*select\s*(!.*)?$",flags=re.I)
def end_select(self,string):
return re.match(self.re_end_select,string) is not None
def end_provider(self, string):
return re.match(self.re_end_provider, string) is not None
re_continuation = re.compile(r"^\s*\S+.*&")
def continuation(self,string):
return re.match(self.re_continuation,string) is not None
re_begin_do = re.compile(r"^\s*do\s+", flags=re.I)
def begin_do(self, string):
return re.match(self.re_begin_do, string) is not None
re_end_do = re.compile(r"^\s*end\s*do\s*(!.*)?$", flags=re.I)
def end_do(self, string):
return re.match(self.re_end_do, string) is not None
re_begin_if = re.compile(r"^\s*if(\(|\s+).*(&|then)\s*(!.*)?$", flags=re.I)
def begin_if(self, string):
return re.match(self.re_begin_if, string) is not None
re_else = re.compile(r"^\s*else", flags=re.I)
def xelse(self, string):
return re.match(self.re_else, string) is not None
re_end_if = re.compile(r"^\s*end\s*if\s*(!.*)?$", flags=re.I)
def end_if(self, string):
return re.match(self.re_end_if, string) is not None
re_begin_select = re.compile(r"^\s*select\s*case", flags=re.I)
def begin_select(self, string):
return re.match(self.re_begin_select, string) is not None
re_case = re.compile(r"^\s*case\s*\(", flags=re.I)
def case(self, string):
return re.match(self.re_case, string) is not None
re_end_select = re.compile(r"^\s*end\s*select\s*(!.*)?$", flags=re.I)
def end_select(self, string):
return re.match(self.re_end_select, string) is not None
re_continuation = re.compile(r"^\s*\S+.*&")
def continuation(self, string):
return re.match(self.re_continuation, string) is not None
re_declaration = re.compile(r"^.*::.*$")
def declaration(self, string):
return re.match(self.re_declaration, string) is not None
re_declaration = re.compile(r"^.*::.*$")
def declaration(self,string):
return re.match(self.re_declaration,string) is not None
grep = Grep()
class indent(object):
def __init__(self):
"""Run the program"""
self.run()
def __init__(self):
"""Run the program"""
self.run()
def format_declaration(self, string, n):
l, r = string.split('::')
return l.strip().ljust(n) + ' :: ' + r.strip()
def format_declaration(self,string,n):
l,r = string.split('::')
return l.strip().ljust(n) + ' :: '+ r.strip()
def format_continuation(self,string,n):
buffer = string.split('&')
if len(buffer) == 1:
l = buffer[0]
return l
else:
l, r = buffer
return l.strip().ljust(69-len(n)) + '&'+ r.strip()
def get_filename(self):
"""The file name is the first argument"""
if '_filename' not in self.__dict__:
try:
self._filename = sys.argv[1]
except:
self._filename = None
return self._filename
filename=property(fget=get_filename)
def get_text(self):
"""The text of the file is a list of lines"""
if '_text' not in self.__dict__:
if self.filename is not None:
f = open(self.filename,'r')
self._text = f.read().splitlines()
f.close()
else:
self._text = sys.stdin.read().splitlines()
return self._text
text=property(fget=get_text)
def indentlevel(self,line):
line = line.rstrip()
k=0
if len(line) > 0:
while line[k] == ' ':
k+=1
return k
def run(self):
lines = self.text
indent0 = " "*self.indentlevel(self.text[0])
k = indent0
line = ""
for i in range(len(self.text)):
prevline = line
line = self.text[i].strip()
if grep.continuation(line):
line = self.format_continuation(line,k)
if grep.continuation(prevline):
print k+2*tab+self.format_continuation(line,k+2*tab)
continue
if grep.begin_subroutine(line):
print line
k = indent0+tab
continue
if grep.begin_function(line):
print line
k = indent0+tab
continue
if grep.begin_program(line):
print line
k = indent0+tab
continue
if grep.begin_provider(line):
if line[0] != '&':
k = indent0+tab
if grep.begin_provider(self.text[i+1].strip()):
print " "+line
else:
print line
def format_continuation(self, string, n):
buffer = string.split('&')
if len(buffer) == 1:
l = buffer[0]
return l
else:
print line
continue
l, r = buffer
return l.strip().ljust(69 - len(n)) + '&' + r.strip()
if grep.declaration(line):
print k+self.format_declaration(line,30)
continue
def get_filename(self):
"""The file name is the first argument"""
if '_filename' not in self.__dict__:
try:
self._filename = sys.argv[1]
except:
self._filename = None
return self._filename
if grep.begin_do(line):
print k+line
k += tab
continue
filename = property(fget=get_filename)
if grep.begin_if(line):
print k+line
k += tab
continue
def get_text(self):
"""The text of the file is a list of lines"""
if '_text' not in self.__dict__:
if self.filename is not None:
f = open(self.filename, 'r')
self._text = f.read().splitlines()
f.close()
else:
self._text = sys.stdin.read().splitlines()
return self._text
if grep.xelse(line):
print k[:-tabn]+line
continue
text = property(fget=get_text)
if grep.begin_select(line):
print k+line
k += 2*tab
continue
def indentlevel(self, line):
line = line.rstrip()
k = 0
if len(line) > 0:
while line[k] == ' ':
k += 1
return k
if grep.case(line):
print k[:-tabn]+line
continue
if grep.end_do(line):
k = k[:-tabn]
print k+line
continue
if grep.end_if(line):
k = k[:-tabn]
print k+line
continue
if grep.end_select(line):
k = k[:-2*tabn]
print k+line
continue
if grep.end_subroutine(line):
print line
def run(self):
lines = self.text
indent0 = " " * self.indentlevel(self.text[0])
k = indent0
continue
line = ""
for i in range(len(self.text)):
prevline = line
line = self.text[i].strip()
if grep.continuation(line):
line = self.format_continuation(line, k)
if grep.end_function(line):
print line
k = indent0
continue
if grep.continuation(prevline):
print k + 2 * tab + self.format_continuation(line, k + 2 * tab)
continue
if grep.end_provider(line):
print line
k = indent0
continue
if grep.begin_subroutine(line):
print line
k = indent0 + tab
continue
if grep.end_program(line):
print line
k = indent0
continue
if grep.begin_function(line):
print line
k = indent0 + tab
continue
print k+line
if grep.begin_program(line):
print line
k = indent0 + tab
continue
if grep.begin_provider(line):
if line[0] != '&':
k = indent0 + tab
if grep.begin_provider(self.text[i + 1].strip()):
print " " + line
else:
print line
else:
print line
continue
if grep.declaration(line):
print k + self.format_declaration(line, 30)
continue
if grep.begin_do(line):
print k + line
k += tab
continue
if grep.begin_if(line):
print k + line
k += tab
continue
if grep.xelse(line):
print k[:-tabn] + line
continue
if grep.begin_select(line):
print k + line
k += 2 * tab
continue
if grep.case(line):
print k[:-tabn] + line
continue
if grep.end_do(line):
k = k[:-tabn]
print k + line
continue
if grep.end_if(line):
k = k[:-tabn]
print k + line
continue
if grep.end_select(line):
k = k[:-2 * tabn]
print k + line
continue
if grep.end_subroutine(line):
print line
k = indent0
continue
if grep.end_function(line):
print line
k = indent0
continue
if grep.end_provider(line):
print line
k = indent0
continue
if grep.end_program(line):
print line
k = indent0
continue
print k + line
def main():
indent()
indent()
if __name__ == '__main__':
main()
main()

48
src/irpf90_t.py
View File

@ -24,7 +24,6 @@
# 31062 Toulouse Cedex 4
# scemama@irsamc.ups-tlse.fr
irpdir = "IRPF90_temp/"
mandir = "IRPF90_man/"
@ -35,6 +34,7 @@ irp_id = abs(crc32(os.getcwd()))
from lib.manager import irpy
from util import logger
class Line(object):
def __init__(self, i, text, filename):
self.i = i
@ -48,36 +48,36 @@ class Line(object):
def __repr__(self):
return "%20s:%5d : %s (%s)" % (type(self).__name__, self.i, self.text, self.filename)
class LineWithName(Line):
@irpy.lazy_property
def subname(self):
buf = self.lower
if not buf.endswith(')'):
buf += "()"
@irpy.lazy_property
def subname(self):
buf = self.lower
if not buf.endswith(')'):
buf += "()"
l_buf = buf.split('(')
l_name = l_buf[0].split()
l_buf = buf.split('(')
l_name = l_buf[0].split()
if len(l_name) < 2:
import loger
logger.error("Syntax Error: %s" % line)
sys.exit(1)
return l_name.pop()
if len(l_name) < 2:
import loger
logger.error("Syntax Error: %s" % line)
sys.exit(1)
return l_name.pop()
l_type = [
'Empty_line', 'Simple_line', "Declaration", "Continue", "Begin_provider",
"Cont_provider", "End_provider", "Begin_doc", "Doc", "End_doc",
"Begin_shell", "End_shell", "Begin_template", "End_template", "Subst",
"Assert", "Touch", "SoftTouch", "Irp_read", "Irp_write", "Irp_If",
"Irp_Else", "Irp_Endif", "Openmp", "Directive", "Use", "Do", "Enddo", "If",
"Elseif", "Else", "Endif", "Select", "Case", "End_select", "Provide", "NoDep", "Return", "Include",
"Implicit", "Free", "End", "Provide_all","Contains",'Type','End_module','Interface','End_interface',
'Where','Elsewhere','Endwhere']
'Empty_line', 'Simple_line', "Declaration", "Continue", "Begin_provider", "Cont_provider",
"End_provider", "Begin_doc", "Doc", "End_doc", "Begin_shell", "End_shell", "Begin_template",
"End_template", "Subst", "Assert", "Touch", "SoftTouch", "Irp_read", "Irp_write", "Irp_If",
"Irp_Else", "Irp_Endif", "Openmp", "Directive", "Use", "Do", "Enddo", "If", "Elseif", "Else",
"Endif", "Select", "Case", "End_select", "Provide", "NoDep", "Return", "Include", "Implicit",
"Free", "End", "Provide_all", "Contains", 'Type', 'End_module', 'Interface', 'End_interface',
'Where', 'Elsewhere', 'Endwhere'
]
for t in l_type:
globals()[t] = type(t, (Line, ), {})
for t in ['Subroutine', 'Function', 'Program', 'Call','Module']:
globals()[t] = type(t, (LineWithName, ), {})
for t in ['Subroutine', 'Function', 'Program', 'Call', 'Module']:
globals()[t] = type(t, (LineWithName, ), {})

17
src/irpman.py
View File

@ -24,17 +24,16 @@
# 31062 Toulouse Cedex 4
# scemama@irsamc.ups-tlse.fr
import os
import sys
if __name__ == "__main__":
from irpf90_t import mandir
entity = sys.argv[1].lower()
filename = '%s.l'% entity
if filename not in os.listdir(mandir):
print "Error: `%s` does not exist"% entity
sys.exit(-1)
from irpf90_t import mandir
entity = sys.argv[1].lower()
os.system("man %s" % os.path.join(mandir,filename))
filename = '%s.l' % entity
if filename not in os.listdir(mandir):
print "Error: `%s` does not exist" % entity
sys.exit(-1)
os.system("man %s" % os.path.join(mandir, filename))

23
src/irpy_files.py
View File

@ -10,6 +10,7 @@ import sys
from command_line import command_line
class Irpy_comm_world(object):
'''Maestro.'''
@ -114,8 +115,8 @@ class Irpy_comm_world(object):
l_duplicate = [x for x in l_ent if l_ent.count(x) > 1]
if l_duplicate:
from util import logger
logger.error('You have duplicate PROVIDER: %s' % ' '.join(
[e.name for e in l_duplicate]))
logger.error('You have duplicate PROVIDER: %s' %
' '.join([e.name for e in l_duplicate]))
import sys
sys.exit(1)
@ -230,7 +231,7 @@ class Irpy_comm_world(object):
d_routine = self.d_routine
import parsed_text
vtuple = [(v,s.same_as, s.regexp) for v, s in d_entity.iteritems()]
vtuple = [(v, s.same_as, s.regexp) for v, s in d_entity.iteritems()]
def worker_parsed(filename_text):
filename, text = filename_text
@ -290,8 +291,16 @@ class Irpy_comm_world(object):
lazy_write_file(filename, '%s\n' % text)
def create_stack(self):
import irp_stack
irp_stack.create()
from util import lazy_write_file
from util import ashes_env
str_ = ashes_env.render('irp_stack.F90', {
'do_debug': command_line.do_debug,
'do_openmp': command_line.do_openmp,
'do_memory': command_line.do_memory
})
filename = os.path.join(irpf90_t.irpdir, 'irp_stack.irp.F90')
lazy_write_file(filename, str_)
def create_buildfile(self, ninja):
import build_file
@ -307,8 +316,8 @@ class Irpy_comm_world(object):
def create_lock(self):
from util import lazy_write_file
from util import ashes_env
from util import ashes_env
str_ = ashes_env.render('irp_lock.F90', {'entity':sorted(self.d_entity)})
str_ = ashes_env.render('irp_lock.F90', {'entity': sorted(self.d_entity)})
filename = os.path.join(irpf90_t.irpdir, 'irp_locks.irp.F90')
lazy_write_file(filename, str_)

129
src/module.py
View File

@ -30,6 +30,7 @@ import preprocessed_text
from util import *
from entity import Entity
def put_info(text, filename):
lenmax = 80 - len(filename)
@ -37,26 +38,25 @@ def put_info(text, filename):
str_ = '{text:{width}} ! {filename}:{i:4}'
for _, line in text:
line.text = str_.format(text=line.text,filename=line.filename,i=line.i,width=lenmax)
line.text = str_.format(text=line.text, filename=line.filename, i=line.i, width=lenmax)
return text
class Fmodule(object):
header = [ "! -*- F90 -*-",
"!",
"!-----------------------------------------------!",
"! This file was generated with the irpf90 tool. !",
"! !",
"! DO NOT MODIFY IT BY HAND !",
"!-----------------------------------------------!",
""]
header = [
"! -*- F90 -*-", "!", "!-----------------------------------------------!",
"! This file was generated with the irpf90 tool. !",
"! !",
"! DO NOT MODIFY IT BY HAND !",
"!-----------------------------------------------!", ""
]
def __init__(self, text, filename, d_variable):
self.text = put_info(text, filename)
self.filename = filename[:-6]
self.name = "%s_mod" % (self.filename).replace('/', '__').replace('.', 'Dot')
self.d_all_variable = d_variable
self.d_all_variable = d_variable
@irpy.lazy_property
def prog_name(self):
@ -75,20 +75,23 @@ class Fmodule(object):
def head(self):
'''The module who containt the declaration of the entity'''
if self.use or self.dec or self.l_entity:
if self.use or self.dec or self.l_entity:
d_template = {'name' : self.name,
'use':list(self.use),'usr_declaration':list(self.dec),
'irp_declaration':[e.d_header for e in self.l_entity],
'coarray': command_line.coarray,
'align': False if command_line.align == 1 else command_line.align}
return [i for i in ashes_env.render('module.f90', d_template).split('\n') if i]
else:
return []
d_template = {
'name': self.name,
'use': list(self.use),
'usr_declaration': list(self.dec),
'irp_declaration': [e.d_header for e in self.l_entity],
'coarray': command_line.coarray,
'align': False if command_line.align == 1 else command_line.align
}
return [i for i in ashes_env.render('module.f90', d_template).split('\n') if i]
else:
return []
@irpy.lazy_property
def has_irp_module(self):
return bool(self.head)
return bool(self.head)
@irpy.lazy_property
def needed_vars(self):
@ -100,23 +103,22 @@ class Fmodule(object):
@irpy.lazy_property
def generated_text(self):
'Routine genereraed by the IRPF90. provide, build, ...'
'Routine genereraed by the IRPF90. provide, build, ...'
result = []
for var in self.l_entity:
result += var.provider
if not var.is_protected:
if not var.is_protected:
result += var.builder
result += var.allocater
result += var.allocater
if var.is_read:
result += var.reader
if var.is_written:
result += var.writer
return result
@irpy.lazy_property
def residual_text_use_dec(self):
def remove_providers(text):
result = []
inside = False
@ -134,21 +136,21 @@ class Fmodule(object):
result = []
variable_list = []
skip_interface = False
skip_interface = False
for vars, line in text:
if type(line) in [Interface, End_interface]:
skip_interface = not skip_interface
if type(line) in [Interface, End_interface]:
skip_interface = not skip_interface
if skip_interface:
result.append((vars, line))
continue
if skip_interface:
result.append((vars, line))
continue
if type(line) in [Subroutine, Function, Program]:
if type(line) in [Subroutine, Function, Program]:
#Deep copy...
variable_list = list(vars)
elif type(line) == End:
result += [([], Use(line.i, x, line.filename)) for x in build_use(variable_list, self.d_all_variable)]
result += [([], Use(line.i, x, line.filename))
for x in build_use(variable_list, self.d_all_variable)]
else:
variable_list += vars
@ -156,19 +158,19 @@ class Fmodule(object):
return result
def extract_use_dec_text(text):
# (List[ Tuple(Entity,Line) ]) -> (List[ Tuple(Entity,Line),List[ Tuple(Entity,Line),List[ Tuple(Entity,Line))
'''Extract the global declaration statement and module use form the declaration of function. '''
# (List[ Tuple(Entity,Line) ]) -> (List[ Tuple(Entity,Line),List[ Tuple(Entity,Line),List[ Tuple(Entity,Line))
'''Extract the global declaration statement and module use form the declaration of function. '''
inside = 0
result,dec,use,module = [],[],[],[]
result, dec, use, module = [], [], [], []
for vars, line in text:
if isinstance(line, (Subroutine, Function, Program,Interface,Module)):
if isinstance(line, (Subroutine, Function, Program, Interface, Module)):
inside += 1
if type(line) == Module:
module.append((vars,line))
if type(line) == Module:
module.append((vars, line))
if inside:
result.append((vars, line))
@ -177,22 +179,22 @@ class Fmodule(object):
use.append((vars, line))
elif type(line) == Declaration:
dec.append((vars, line))
if isinstance(line,(End,End_interface,End_module)):
inside += -1
if inside:
print 'Something wrong append'
sys.exit(1)
if isinstance(line, (End, End_interface, End_module)):
inside += -1
if inside:
print 'Something wrong append'
sys.exit(1)
return use, module, dec, result
result = remove_providers(self.text)
result = modify_functions(result)
from collections import namedtuple
Residual_text_use_dec = namedtuple('Residual_text_use_dec', ['use', 'module', 'dec', 'result'])
Residual_text_use_dec = namedtuple('Residual_text_use_dec',
['use', 'module', 'dec', 'result'])
return Residual_text_use_dec(*extract_use_dec_text(result))
@ -202,12 +204,12 @@ class Fmodule(object):
@irpy.lazy_property
def gen_mod(self):
'''List of module generated by the user in this module...'''
'''List of module generated by the user in this module...'''
return set("%s" % line.subname for _, line in self.residual_text_use_dec.module)
@irpy.lazy_property
def dec(self):
'''The declaration of this module
'''The declaration of this module
Note:
Because user can define F90 Type, we need to keep the correct order.
@ -224,10 +226,10 @@ class Fmodule(object):
'''
l = [" %s" % line.text for _, line in self.residual_text_use_dec.dec]
from util import uniquify
if len(l) != len(uniquify(l)):
raise NotImplementedError
l = [" %s" % line.text for _, line in self.residual_text_use_dec.dec]
from util import uniquify
if len(l) != len(uniquify(l)):
raise NotImplementedError
return l
@ -241,29 +243,28 @@ class Fmodule(object):
result += map(lambda x: ([], Simple_line(line.i, x, line.filename)),
build_call_provide(vars, self.d_all_variable))
from parsed_text import move_to_top_list, move_interface
move_to_top_list(result, [Declaration, Implicit, Use])
move_interface(result)
move_interface(result)
return [line.text for _, line in result]
return [line.text for _, line in result]
@irpy.lazy_property
def needed_modules(self):
l = set(x.split(',only').pop(0).split()[1] for x in self.generated_text + self.head + self.residual_text if x.lstrip().startswith("use "))
l = set(
x.split(',only').pop(0).split()[1]
for x in self.generated_text + self.head + self.residual_text
if x.lstrip().startswith("use "))
if self.name in l:
l.remove(self.name)
return l
@irpy.lazy_property
def needed_modules_irp(self):
return [i for i in self.needed_modules if i.endswith("_mod")]
@irpy.lazy_property
def needed_modules_usr(self):
return [i for i in self.needed_modules if not i.endswith("_mod")]
return [i for i in self.needed_modules if not i.endswith("_mod")]

160
src/parsed_text.py
View File

@ -35,7 +35,7 @@ regexps_re_string_sub = regexps.re_string.sub
def find_variables_in_line(line, vtuple):
line_lower = regexps_re_string_sub('', line.lower)
#return [same_as for v,same_as, regexp in vtuple if v in line_lower and regexp(line_lower)]
return [v for v,same_as, regexp in vtuple if v in line_lower and regexp(line_lower)]
return [v for v, same_as, regexp in vtuple if v in line_lower and regexp(line_lower)]
def find_funcs_in_line(line, stuple):
@ -66,10 +66,11 @@ def check_touch(variables, line, vars, main_vars):
if x != y:
message = "The following entities should be touched:"
message = "\n".join([message] + map(lambda x: "- %s" % (x, ), all_others))
from util import logger
logger.error("%s (%s)" % (message,line))
import sys
sys.exit(1)
from util import logger
logger.error("%s (%s)" % (message, line))
import sys
sys.exit(1)
from collections import namedtuple
Parsed_text = namedtuple('Parsed_text', ['varlist', 'line'])
@ -100,7 +101,7 @@ def get_parsed_text(filename, text, variables, subroutines, vtuple):
variable_list = find_variables_in_line(line, vtuple)
variable_list.remove(v)
# variable_list.remove(variables[v].same_as)
# variable_list.remove(variables[v].same_as)
append(Parsed_text(variable_list, line))
@ -113,9 +114,9 @@ def get_parsed_text(filename, text, variables, subroutines, vtuple):
l = filter(lambda x: x not in varlist, l)
for v in l:
if v not in variables:
logger.error("Variable %s is unknown (%s)" % (v,line))
import sys
sys.exit(1)
logger.error("Variable %s is unknown (%s)" % (v, line))
import sys
sys.exit(1)
append(Parsed_text(l, Provide(line.i, "", line.filename)))
append(Parsed_text(l, Simple_line(line.i, "!%s" % (line.text), line.filename)))
@ -125,7 +126,7 @@ def get_parsed_text(filename, text, variables, subroutines, vtuple):
for v in l:
if v not in variables:
error.fail(line, "Variable %s is unknown" % (v))
sys.exit(1)
sys.exit(1)
l = map(lambda x: "-%s" % (x), l)
append(Parsed_text(l, Simple_line(line.i, "!%s" % (line.text), line.filename)))
@ -157,8 +158,9 @@ def get_parsed_text(filename, text, variables, subroutines, vtuple):
def fun(x):
if x not in variables:
error.fail(line, "Variable %s unknown" % (x, ))
return Parsed_text(
[], Simple_line(line.i, " %s_is_built = .True." % (x, ), line.filename))
return Parsed_text([],
Simple_line(line.i, " %s_is_built = .True." %
(x, ), line.filename))
result += map(fun, main_vars[:-1])
if type(line) == SoftTouch:
@ -206,6 +208,7 @@ def get_parsed_text(filename, text, variables, subroutines, vtuple):
return (filename, result)
######################################################################
def move_to_top_list(text, it):
# ( List[ List[Entity], Line], Iterator)
@ -239,16 +242,16 @@ def move_to_top_list(text, it):
for i, (l_var, line) in enumerate(text):
t = type(line)
if t in [Begin_provider, Module,Program, Subroutine, Function]:
if t in [Begin_provider, Module, Program, Subroutine, Function]:
l_begin.append(i)
elif t in [End_provider, End]:
l_begin.pop()
l_begin.pop()
elif l_begin and t in it:
d_permutation[t].append( (l_begin[-1], [l_var, line]) )
# Put the sentinel, will be deleted after the insertion
text[i] = None
d_permutation[t].append((l_begin[-1], [l_var, line]))
# Put the sentinel, will be deleted after the insertion
text[i] = None
# ~ # ~ # ~
# O r d e r t h e m
@ -272,33 +275,35 @@ def move_to_top_list(text, it):
# Now do the Delete part of the move. Fortunatly we put a sentinel to know the line to delete
for i in reversed(xrange(len(text))):
if text[i] is None:
del text[i]
if text[i] is None:
del text[i]
def move_interface(parsed_text,s_type=(Use,Implicit,Declaration,Subroutine,Function,Module)):
# ( List[ List[Entity], Line], Iterator)
'''Move everything containt into 'interface' below the first instance of s_type who preced it
def move_interface(parsed_text, s_type=(Use, Implicit, Declaration, Subroutine, Function, Module)):
# ( List[ List[Entity], Line], Iterator)
'''Move everything containt into 'interface' below the first instance of s_type who preced it
Note:
= This function is unpur
'''
# Get the born of the interface
i_begin = [ i for i, (_, line) in enumerate(parsed_text) if isinstance(line,Interface) ]
i_end = [ i+1 for i, (_, line) in enumerate(parsed_text) if isinstance(line,End_interface) ]
# Get the born of the interface
i_begin = [i for i, (_, line) in enumerate(parsed_text) if isinstance(line, Interface)]
i_end = [i + 1 for i, (_, line) in enumerate(parsed_text) if isinstance(line, End_interface)]
# Get the begin of the insert
i_insert = []
for begin in i_begin:
i_insert.append(next(i+1 for i in range(begin,-1,-1) if isinstance(parsed_text[i][1], s_type)))
# Get the begin of the insert
i_insert = []
for begin in i_begin:
i_insert.append(
next(i + 1 for i in range(begin, -1, -1) if isinstance(parsed_text[i][1], s_type)))
# Do the insert and the delete in one passe
for insert, begin, end in zip(i_insert,i_begin,i_end):
parsed_text[insert:insert] = parsed_text[begin:end]
for insert, begin, end in zip(i_insert, i_begin, i_end):
parsed_text[insert:insert] = parsed_text[begin:end]
padding = end - begin
parsed_text[begin + padding:end + padding] = []
padding = end-begin
parsed_text[begin+padding:end+padding] = []
######################################################################
def build_sub_needs(parsed_text, d_subroutine):
@ -311,10 +316,14 @@ def build_sub_needs(parsed_text, d_subroutine):
l_buffer = []
for _, text in parsed_text:
l_begin = [ i for i, (_, line) in enumerate(text) if isinstance(line, (Subroutine, Function, Program))]
l_begin = [
i for i, (_, line) in enumerate(text)
if isinstance(line, (Subroutine, Function, Program))
]
l_end = [i for i, (_, line) in enumerate(text) if isinstance(line, End)]
l_buffer += [(d_subroutine[text[b].line.subname], text[b + 1:e]) for b, e in zip(l_begin, l_end) if not isinstance(text[b].line, Program)]
l_buffer += [(d_subroutine[text[b].line.subname], text[b + 1:e])
for b, e in zip(l_begin, l_end) if not isinstance(text[b].line, Program)]
for sub, text in l_buffer:
sub.needs = set(v for vs, _ in text for v in vs)
@ -347,42 +356,42 @@ def raise_entity(text):
skip_interface = False
lvl = 0
for i,(e, line) in enumerate(text):
type_ = type(line)
for i, (e, line) in enumerate(text):
type_ = type(line)
if type_ in [Interface, End_interface]:
skip_interface = not skip_interface
skip_interface = not skip_interface
if skip_interface:
continue
continue
if type_ in [Begin_provider, Program, Subroutine, Function,If]:
l_token.append(i)
lvl += 1
d_level_var[lvl] = e[:]
elif type_ in [End_provider, End, Endif]:
i = l_token.pop()
text[i] = ( d_level_var[lvl],text[i][1])
if type_ in [Begin_provider, Program, Subroutine, Function, If]:
l_token.append(i)
lvl += 1
d_level_var[lvl] = e[:]
lvl += -1
elif type_ in [End_provider, End, Endif]:
i = l_token.pop()
text[i] = (d_level_var[lvl], text[i][1])
elif type_ in [Else,Elseif]:
i = l_token.pop()
text[i] = ( d_level_var[lvl],text[i][1])
lvl += -1
assert (type(text[i][1]) == If)
l_token.append(i)
d_level_var[lvl] = e[:]
elif type_ in [Else, Elseif]:
i = l_token.pop()
text[i] = (d_level_var[lvl], text[i][1])
assert (type(text[i][1]) == If)
l_token.append(i)
d_level_var[lvl] = e[:]
else:
d_level_var[lvl] += e[:]
text[i] = ([], line)
assert (lvl == 0)
else:
d_level_var[lvl] += e[:]
text[i] = ([],line)
assert(lvl==0)
def move_variables(parsed_text):
#(List[ Tuple[List[Entity], Tuple[int,List[Line]] ]]
'''Move variables into the top of the declaraiton.
@ -390,7 +399,6 @@ def move_variables(parsed_text):
This need to be optimised to handle the fact that we can have multi-provider
'''
def func(filename, text):
result = []
append = result.append
@ -403,16 +411,16 @@ def move_variables(parsed_text):
old_elsevars = []
revtext = list(text)
revtext.reverse()
skip_interface = False
skip_interface = False
try:
for vars, line in revtext:
if type(line) in [Interface, End_interface]:
skip_interface = not skip_interface
if skip_interface:
append(([], line))
continue
if type(line) in [Interface, End_interface]:
skip_interface = not skip_interface
if skip_interface:
append(([], line))
continue
if type(line) in [End_provider, End]:
varlist = []
@ -456,10 +464,10 @@ def move_variables(parsed_text):
varlist += vars
append(([], line))
except:
from util import logger
from util import logger
logger.error("Unable to parse file %s", line)
import sys
sys.exit(1)
import sys
sys.exit(1)
result.reverse()
@ -554,7 +562,6 @@ def build_needs(parsed_text, subroutines, stuple, variables):
entity.needs = uniquify(l_needs)
# Now do the Other entity
for v in variables:
main = variables[v].same_as
@ -573,7 +580,7 @@ def build_needs(parsed_text, subroutines, stuple, variables):
d_needed_by[x].append(var.name)
for v in d_needed_by:
variables[v].needed_by = uniquify(d_needed_by[v])
variables[v].needed_by = uniquify(d_needed_by[v])
######################################################################
from command_line import command_line
@ -612,4 +619,3 @@ def perform_loop_substitutions(parsed_text):
append((vars, line))
main_result.append((filename, result))
return main_result

268
src/preprocessed_text.py
View File

@ -37,7 +37,7 @@ re_enddo = re.compile("end +do")
re_endwhere = re.compile("end +where")
re_endtype = re.compile("end +type.*")
re_endmodule = re.compile("end +module",re.I)
re_endmodule = re.compile("end +module", re.I)
re_endselect = re.compile("end +select")
re_endinterface = re.compile("end +interface")
@ -102,6 +102,7 @@ simple_dict = {
"endwhere": Endwhere,
}
def get_canonized_text(text_lower):
text_canonized = text_lower
@ -112,7 +113,7 @@ def get_canonized_text(text_lower):
text_canonized = re_endif.sub("endif", text_canonized)
text_canonized = re_endselect.sub("endselect", text_canonized)
text_canonized = re_endinterface.sub("endinterface", text_canonized)
text_canonized = re_endwhere.sub('endwhere',text_canonized)
text_canonized = re_endwhere.sub('endwhere', text_canonized)
for c in """()'"[]""":
text_canonized = text_canonized.replace(c, " %s " % c)
@ -122,7 +123,7 @@ def get_canonized_text(text_lower):
def get_type(i, filename, line, line_lower, line_lower_canonized, is_doc):
# ( int,str,str,str,str,bool) -> Irpf90_t
'''Find the type of a text line'''
line = line.rstrip()
l_word = line_lower_canonized.split()
@ -132,11 +133,11 @@ def get_type(i, filename, line, line_lower, line_lower_canonized, is_doc):
# Handle archaic do loop of f77
firstword = l_word[0]
if firstword.isdigit():
l_word = l_word[1:]
l_word = l_word[1:]
firstword = l_word[0]
if firstword == "contains":
return [Contains(i, line, filename)], False
return [Contains(i, line, filename)], False
if firstword == "end_doc":
return [End_doc(i, line, filename)], False
@ -150,12 +151,10 @@ def get_type(i, filename, line, line_lower, line_lower_canonized, is_doc):
type_ = simple_dict[firstword]
return [type_(i, line, filename)], is_doc
#label do-loop (outer: do i=1,sze)
reg_do_lab = ur":\s+do\s+"
if re.search(reg_do_lab,line_lower):
return [Do(i,line,filename)], is_doc
if re.search(reg_do_lab, line_lower):
return [Do(i, line, filename)], is_doc
lower_line = line_lower.strip()[1:]
@ -173,10 +172,10 @@ def get_type(i, filename, line, line_lower, line_lower_canonized, is_doc):
result = [Simple_line(i, line, filename)]
logger.info("%s:"
"irpf90 may not work with preprocessor directives. You can use"
"irpf90 may not work with preprocessor directives. You can use"
"Irp_if ... Irp_else ... Irp_endif"
"instead of"
"#ifdef ... #else ... #endif"%line)
"#ifdef ... #else ... #endif" % line)
return result, is_doc
if firstword.startswith("case("):
@ -192,7 +191,7 @@ def get_type(i, filename, line, line_lower, line_lower_canonized, is_doc):
# Detect errors
if firstword == "dowhile":
logger.error("%s 'do while' should be in 2 words." % Do(i, line, filename))
sys.exit(1)
sys.exit(1)
return [Simple_line(i, line, filename)], is_doc
@ -216,11 +215,16 @@ def save_and_execute(irpdir, scriptname, code, interpreter):
# Execute shell
import util
try:
text = util.check_output('PYTHONPATH=$PYTHONPATH:. %s %s' % (interpreter, irpdir_scriptname), shell=True, bufsize=-1, cwd=os.path.join(irpdir,'..'))
text = util.check_output(
'PYTHONPATH=$PYTHONPATH:. %s %s' % (interpreter, irpdir_scriptname),
shell=True,
bufsize=-1,
cwd=os.path.join(irpdir, '..'))
except:
util.logger.error("Something wrong append with embeded '%s' script: %s"% (interpreter, irpdir_scriptname))
import sys
sys.exit(1)
util.logger.error("Something wrong append with embeded '%s' script: %s" %
(interpreter, irpdir_scriptname))
import sys
sys.exit(1)
# Create the Line
p = Preprocess_text(scriptname)
@ -233,35 +237,35 @@ def execute_shell(text):
# (List[Line]) -> List[Line]
'''Execute the embedded shell scripts'''
l_begin = [i for i,line in enumerate(text) if isinstance(line,Begin_shell)]
l_end = [i for i,line in enumerate(text) if isinstance(line,End_shell)]
l_output= []
l_begin = [i for i, line in enumerate(text) if isinstance(line, Begin_shell)]
l_end = [i for i, line in enumerate(text) if isinstance(line, End_shell)]
l_output = []
# ~=~=~=~
# E x e c u t e S h e l l
# ~=~=~=~
from util import logger
import sys
def fail(l, a, b):
logger.error("%s In Begin_Shell, %s '%s'" % (l,a, b))
sys.exit(1)
logger.error("%s In Begin_Shell, %s '%s'" % (l, a, b))
sys.exit(1)
for begin,end in zip(l_begin,l_end):
for begin, end in zip(l_begin, l_end):
header = text[begin]
header_text = header.text
header = text[begin]
header_text = header.text
for bracket in ['[', ']']:
n = header_text.count(bracket)
assert n <= 1, fail(header_text, "Too many", bracket)
assert n >= 1, fail(header_text, "Missing", bracket)
else:
interpreter = header_text[header_text.find('[')+1: header_text.find(']')].strip()
script = ['%s\n' % l.text for l in text[begin+1:end] ]
scriptname="%s_shell_%d" % (header.filename, header.i)
n = header_text.count(bracket)
assert n <= 1, fail(header_text, "Too many", bracket)
assert n >= 1, fail(header_text, "Missing", bracket)
else:
interpreter = header_text[header_text.find('[') + 1:header_text.find(']')].strip()
script = ['%s\n' % l.text for l in text[begin + 1:end]]
scriptname = "%s_shell_%d" % (header.filename, header.i)
l_output.append(save_and_execute(irpdir, scriptname, script,interpreter))
l_output.append(save_and_execute(irpdir, scriptname, script, interpreter))
# ~=~=~=~
# R e p l a c e
@ -271,12 +275,12 @@ def execute_shell(text):
text_new = text[:]
# Because we use slicing and we want to include the end line
l_end_include = [i+1 for i in l_end]
l_end_include = [i + 1 for i in l_end]
padding = 0
for begin,end, out in zip(l_begin,l_end_include,l_output):
text_new[begin+padding:end+padding] = out
padding += len(out) - (end-begin)
for begin, end, out in zip(l_begin, l_end_include, l_output):
text_new[begin + padding:end + padding] = out
padding += len(out) - (end - begin)
return text_new
@ -343,7 +347,11 @@ def execute_templates(text):
for v in variables:
script += " t0 = t0.replace('%s',d['%s'])\n" % (v, v)
script += " print t0\n"
result += save_and_execute(irpdir, scriptname="%s_template_%d" % (line.filename, line.i), code=script,interpreter="python")
result += save_and_execute(
irpdir,
scriptname="%s_template_%d" % (line.filename, line.i),
code=script,
interpreter="python")
else:
subst += line.text + '\n'
@ -415,26 +423,25 @@ def remove_comments(text, form):
result = []
def remove_after_bang(str_):
# str -> str
i_bang = str_.find('!')
if i_bang == -1:
return str_
else:
sentinel, inside = None, False
for i,c in enumerate(str_):
if c == '"' or c == "'":
if not inside:
inside = True
sentinel = c
elif sentinel == c:
inside = False
# str -> str
i_bang = str_.find('!')
elif c == '!' and not inside:
return str_[:i].strip()
return str_
if i_bang == -1:
return str_
else:
sentinel, inside = None, False
for i, c in enumerate(str_):
if c == '"' or c == "'":
if not inside:
inside = True
sentinel = c
elif sentinel == c:
inside = False
elif c == '!' and not inside:
return str_[:i].strip()
return str_
if form == Free_form:
for line in text:
@ -445,10 +452,10 @@ def remove_comments(text, form):
else:
newline = line.text.lstrip()
if (newline != "" and newline[0] != "!#"):
text = remove_after_bang(line.text)
if text:
line.text = text
result.append(line)
text = remove_after_bang(line.text)
if text:
line.text = text
result.append(line)
return result
else:
@ -514,7 +521,7 @@ def irp_simple_statements(text):
'''Processes simple statements'''
def process_irp_rw(line, rw, t):
'''Read Write'''
'''Read Write'''
assert type(line) == t
buffer = line.text.split()
if len(buffer) == 2:
@ -547,7 +554,7 @@ def irp_simple_statements(text):
def process_return(line):
assert type(line) == Return
if command_line.do_assert or command_line.do_debug:
if command_line.do_debug:
newline = Simple_line(line.i, " call irp_leave(irp_here)", line.filename)
result = [newline, line]
else:
@ -603,7 +610,7 @@ def irp_simple_statements(text):
def process_end(line):
'''Add irp_leave if necessary'''
if command_line.do_assert or command_line.do_debug:
if command_line.do_debug:
i = line.i
f = line.filename
result = [Simple_line(i, " call irp_leave(irp_here)", f), line]
@ -614,11 +621,15 @@ def irp_simple_statements(text):
def process_begin_provider(line):
assert type(line) == Begin_provider
import string
trans = string.maketrans("[]"," ")
trans = string.maketrans("[]", " ")
buffer = line.lower.translate(trans).split(',')
if len(buffer) < 2:
error.fail(line, "Error in Begin_provider statement")
import sys
print line
print "Error in Begin_provider statement"
sys.exit(1)
varname = buffer[1].strip()
length = len(varname)
i = line.i
@ -627,7 +638,7 @@ def irp_simple_statements(text):
Begin_provider(i, line.text, (f, varname)),
Declaration(i, " character*(%d) :: irp_here = '%s'" % (length, varname), f)
]
if command_line.do_assert or command_line.do_debug:
if command_line.do_debug:
result += [Simple_line(i, " call irp_enter(irp_here)", f), ]
return result
@ -647,23 +658,25 @@ def irp_simple_statements(text):
length = len(subname)
i = line.i
f = line.filename
result = [ line, Declaration(i, " character*(%d) :: irp_here = '%s'" % (length, subname), f)]
result = [
line, Declaration(i, " character*(%d) :: irp_here = '%s'" % (length, subname), f)
]
if command_line.do_assert or command_line.do_debug:
result += [Simple_line(i, " call irp_enter_f(irp_here)", f), ]
if command_line.do_debug:
result += [Simple_line(i, " call irp_enter_routine(irp_here)", f), ]
return result
def process_function(line):
assert type(line) == Function
subname = line.subname
subname = line.subname
length = len(subname)
i = line.i
f = line.filename
result = [
line, Declaration(i, " character*(%d) :: irp_here = '%s'" % (length, subname), f)
]
if command_line.do_assert or command_line.do_debug:
result += [Simple_line(i, " call irp_enter_f(irp_here)", f), ]
if command_line.do_debug:
result += [Simple_line(i, " call irp_enter_routine(irp_here)", f), ]
return result
def process_program(line):
@ -671,15 +684,17 @@ def irp_simple_statements(text):
program_name = line.lower.split()[1]
temp = [Program(0, "program irp_program", program_name)]
if command_line.do_Task:
for i in [" call omp_set_nested(.TRUE.)", "!$omp parallel", "!$omp single"]:
temp += [Simple_line(0, i, line.filename)]
if command_line.do_Task:
for i in [" call omp_set_nested(.TRUE.)", "!$omp parallel", "!$omp single"]:
temp += [Simple_line(0, i, line.filename)]
if command_line.do_profile:
temp += [Simple_line(0, "call irp_init_timer()", line.filename)]
# Need to choose between lazy lock or are big full initialization
# if command_line.do_openmp:
# temp += [Simple_line(0, " call irp_init_locks_%s()" % (irp_id), line.filename)]
if command_line.do_debug or command_line.do_assert:
temp += [Simple_line(0, " CALL irp_stack_init", line.filename)]
temp += [Call(0, " call %s" % (program_name), line.filename)]
if command_line.do_profile:
@ -687,9 +702,9 @@ def irp_simple_statements(text):
temp += [Simple_line(0, " call irp_finalize_%s()" % (irp_id), line.filename)]
if command_line.do_Task:
for i in ["!$omp taskwait","!$omp end single", "!$omp end parallel"]:
temp += [Simple_line(0, i, line.filename)]
if command_line.do_Task:
for i in ["!$omp taskwait", "!$omp end single", "!$omp end parallel"]:
temp += [Simple_line(0, i, line.filename)]
temp += [End(0, "end program", line.filename)]
@ -712,7 +727,6 @@ def irp_simple_statements(text):
Program: process_program,
}
result = []
for line in text:
buffer = [line]
@ -756,15 +770,16 @@ def process_old_style_do(text):
DO 1 i=1,10'''
def change_matching_enddo(begin, number):
for i,line in enumerate(text[begin+1:]):
if isinstance(line,(Continue,Enddo)) and line.text.split()[0] == number:
text[begin+1+i] = Enddo(line.i, " enddo", line.filename)
return
for i, line in enumerate(text[begin + 1:]):
if isinstance(line, (Continue, Enddo)) and line.text.split()[0] == number:
text[begin + 1 + i] = Enddo(line.i, " enddo", line.filename)
return
from util import logger
logger.error(text[begin], "(%s) Old-style do loops should end with 'continue' or 'end do'" % text[begin])
from util import sys
sys.exit(1)
from util import logger
logger.error(text[begin], "(%s) Old-style do loops should end with 'continue' or 'end do'" %
text[begin])
from util import sys
sys.exit(1)
result = []
for i in range(len(text)):
@ -801,9 +816,9 @@ def change_single_line_ifs(text):
else:
buffer = line.text
begin = buffer.find('(')
if begin == -1:
logger.error("No '(' in if statemnt: %s" % line)
sys.exit(1)
if begin == -1:
logger.error("No '(' in if statemnt: %s" % line)
sys.exit(1)
level = 0
instring = False
@ -821,14 +836,14 @@ def change_single_line_ifs(text):
break
if level != 0:
logger.error("If statement not valid: %s (%s)" % (line, line.filename))
sys.exit(1)
sys.exit(1)
test = buffer[:end]
code = buffer[end:]
i = line.i
f = line.filename
result.append(If(i, "%s then" % (test, ), f))
result += get_type(i, f, code, code.lower(),code.lower(), False)[0]
result += get_type(i, f, code, code.lower(), code.lower(), False)[0]
result.append(Endif(i, " endif", f))
else:
result.append(line)
@ -847,35 +862,40 @@ def check_begin_end(raw_text):
Maybe more of one 'x' statement in defined cause in 'ifdef/else/endif' statement.
'''
d_block = {Enddo: [Do],
Endif: [If],
End_provider: [Begin_provider],
End_doc: [Begin_doc],
End: [Program, Subroutine, Function],
End_module: [Module],
End_interface: [Interface]}
d_block = {
Enddo: [Do],
Endif: [If],
End_provider: [Begin_provider],
End_doc: [Begin_doc],
End: [Program, Subroutine, Function],
End_module: [Module],
End_interface: [Interface]
}
from collections import defaultdict
d_type = defaultdict(list)
for line in raw_text:
d_type[type(line)].append(line)
d_type[type(line)].append(line)
for t_end, l_begin in d_block.iteritems():
n_end = len(d_type[t_end])
n_begin = sum(len(d_type[t_begin]) for t_begin in l_begin)
if n_end != n_begin:
if n_end > n_begin:
logger.error("You have more close statement than open statement (%s) (%s)",line.filename,t_end)
else:
logger.error('You have more end statement than open statenemt for (%s) (%s)' % (line.filename, t_end))
for i in zip([l for i in l_begin for l in d_type[i]], d_type[t_end]):
n_end = len(d_type[t_end])
n_begin = sum(len(d_type[t_begin]) for t_begin in l_begin)
if n_end != n_begin:
if n_end > n_begin:
logger.error("You have more close statement than open statement (%s) (%s)",
line.filename, t_end)
else:
logger.error('You have more end statement than open statenemt for (%s) (%s)' %
(line.filename, t_end))
for i in zip([l for i in l_begin for l in d_type[i]], d_type[t_end]):
logger.debug(i)
sys.exit(1)
sys.exit(1)
######################################################################
def remove_ifdefs(text):
@ -927,14 +947,14 @@ class Preprocess_text(object):
def text(self):
with open(self.filename, 'r') as f:
str_ = f.read()
#Dirty thing. We will replace 'end program' by 'end subroutine'
#because afterward the program will be replaced by a subroutine...
import re
transform = re.compile(re.escape('end program'), re.IGNORECASE)
return transform.sub('end subroutine', str_)
#Dirty thing. We will replace 'end program' by 'end subroutine'
#because afterward the program will be replaced by a subroutine...
import re
transform = re.compile(re.escape('end program'), re.IGNORECASE)
return transform.sub('end subroutine', str_)
@irpy.lazy_property_mutable
def text_align(self):
@ -967,7 +987,8 @@ class Preprocess_text(object):
result = []
is_doc = False
for i, (l, ll, llc) in enumerate(zip(self.lines, self.lines_lower, self.lines_lower_canonized)):
for i, (l, ll,
llc) in enumerate(zip(self.lines, self.lines_lower, self.lines_lower_canonized)):
line, is_doc = get_type(i + 1, self.filename, l, ll, llc, is_doc)
result += line
return result
@ -994,6 +1015,5 @@ class Preprocess_text(object):
return result
if __name__ == '__main__':
debug()

49
src/profile.py
View File

@ -24,7 +24,6 @@
# 31062 Toulouse Cedex 4
# scemama@irsamc.ups-tlse.fr
rdtsc = """
#ifdef __i386
double irp_rdtsc_(void) {
@ -47,14 +46,16 @@ import os
import threading
from irpf90_t import irpdir
def build_rdtsc():
filename = irpdir+"irp_rdtsc.c"
file = open(filename,'w')
file.write(rdtsc)
file.close()
filename = irpdir + "irp_rdtsc.c"
file = open(filename, 'w')
file.write(rdtsc)
file.close()
def build_module(variables):
data = """
data = """
module irp_timer
double precision :: irp_profile(3,%(n)d)
integer :: irp_order(%(n)d)
@ -153,23 +154,23 @@ subroutine irp_print_timer()
print *, 'rdtsc latency :', irp_rdtsc_shift, ' cycles'
end
"""
label = {}
for i in variables:
vi = variables[i]
label[vi.label] = vi.same_as
text = []
lmax = 0
for l in label:
text.append(" irp_profile_label(%d) = '%s'"%(l,label[l]))
lmax = max(lmax,l)
text.sort()
text = '\n'.join(text)
data = data%{'text': text, 'n':lmax}
file = open("IRPF90_temp/irp_profile.irp.F90",'w')
file.write(data)
file.close()
label = {}
for i in variables:
vi = variables[i]
label[vi.label] = vi.same_as
text = []
lmax = 0
for l in label:
text.append(" irp_profile_label(%d) = '%s'" % (l, label[l]))
lmax = max(lmax, l)
text.sort()
text = '\n'.join(text)
data = data % {'text': text, 'n': lmax}
file = open("IRPF90_temp/irp_profile.irp.F90", 'w')
file.write(data)
file.close()
def run(d_entity):
build_module(d_entity)
build_rdtsc()
build_module(d_entity)
build_rdtsc()

32
src/regexps.py
View File

@ -24,34 +24,18 @@
# 31062 Toulouse Cedex 4
# scemama@irsamc.ups-tlse.fr
import re
re_comment = re.compile(r"^([^'!]*)('[^']*'[^']*)*!")
re_decl = re.compile( "".join( [ r"^\ *",
r"(integer[(::)?\* ,]+",
r"|double *precision[(::)?\* ,]+",
r"|logical[(::)?\* ,]+",
r"|character[(::)?\* ,]+",
r"|real[(::)?\* ,]+",
r"|dimension[(::)?\* ,]+",
r"|parameter[(::)?\* ,]+",
r"|data */",
r"|allocatable *(::)?",
r"|common */",
r"|namelist */",
r"|save */",
r"|complex[(::)?\* ,]+",
r"|intrinsic *(::)?",
r"|external *(::)?",
r"|equivalence *(::)?",
r"|type",
r"|endtype",
r")[^=(]"
] ) )
re_decl = re.compile("".join([
r"^\ *", r"(integer[(::)?\* ,]+", r"|double *precision[(::)?\* ,]+", r"|logical[(::)?\* ,]+",
r"|character[(::)?\* ,]+", r"|real[(::)?\* ,]+", r"|dimension[(::)?\* ,]+",
r"|parameter[(::)?\* ,]+", r"|data */", r"|allocatable *(::)?", r"|common */", r"|namelist */",
r"|save */", r"|complex[(::)?\* ,]+", r"|intrinsic *(::)?", r"|external *(::)?",
r"|equivalence *(::)?", r"|type", r"|endtype", r")[^=(]"
]))
re_test = re.compile(r"\( *(.*)(\.[a-zA-Z]*\.|[<>]=?|[=/]=)([^=]*)\)")
re_test = re.compile(r"\( *(.*)(\.[a-zA-Z]*\.|[<>]=?|[=/]=)([^=]*)\)")
re_string = re.compile(r"'.*?'")

111
src/routine.py
View File

@ -24,77 +24,80 @@
# 31062 Toulouse Cedex 4
# scemama@irsamc.ups-tlse.fr
from irpf90_t import *
from util import logger
from lib.manager import irpy
class Routine(object):
'''
class Routine(object):
'''
A collection of list corresponding of a Routine (Subroutine, or function)
'''
############################################################
def __init__(self, text):
assert type(text) == list
assert len(text) > 0
############################################################
def __init__(self,text):
assert type(text) == list
assert len(text) > 0
self.text = text
self.prototype = self.text[0]
assert isinstance(self.prototype, (Subroutine, Function))
self.text = text
self.prototype = self.text[0]
assert isinstance(self.prototype, (Subroutine, Function))
############################################################
@irpy.lazy_property_mutable
def called_by(self):
raise AttributeError
############################################################
@irpy.lazy_property_mutable
def called_by(self):
raise AttributeError
############################################################
@irpy.lazy_property
def name(self):
'''Name is lowercase'''
return self.prototype.subname
############################################################
############################################################
@irpy.lazy_property
def is_function(self):
return "function" in self.prototype.lower
@irpy.lazy_property
def name(self):
'''Name is lowercase'''
return self.prototype.subname
############################################################
@irpy.lazy_property
def is_subroutine(self):
return "subroutine" in self.prototype.lower
############################################################
@irpy.lazy_property
def is_function(self):
return "function" in self.prototype.lower
############################################################
@irpy.lazy_property
def doc(self):
############################################################
@irpy.lazy_property
def is_subroutine(self):
return "subroutine" in self.prototype.lower
l_doc = [ l for l in self.text if isinstance(l,Doc) ]
if not l_doc:
logger.info("Subroutine '%s' is not documented"%(self.name))
return [l.text.lstrip()[1:] for l in l_doc]
############################################################
@irpy.lazy_property
def doc(self):
############################################################
@irpy.lazy_property
def touches_my_self(self):
return set(x for line in self.text for x in line.text.split()[1:] if isinstance(line,(Touch, SoftTouch)))
l_doc = [l for l in self.text if isinstance(l, Doc)]
if not l_doc:
logger.info("Subroutine '%s' is not documented" % (self.name))
return [l.text.lstrip()[1:] for l in l_doc]
@irpy.lazy_property_mutable
def touches_ancestor(self):
raise AttributeError
############################################################
@irpy.lazy_property
def touches_my_self(self):
return set(x for line in self.text for x in line.text.split()[1:]
if isinstance(line, (Touch, SoftTouch)))
@irpy.lazy_property
def touches(self):
return list(self.touches_my_self.union(self.touches_ancestor))
@irpy.lazy_property_mutable
def touches_ancestor(self):
raise AttributeError
############################################################
@irpy.lazy_property
def regexp(self):
import re
return re.compile(r"([^a-z0-9'\"_]|^)%s([^a-z0-9_]|$)"%(self.name),re.I)
@irpy.lazy_property
def touches(self):
return list(self.touches_my_self.union(self.touches_ancestor))
############################################################
@irpy.lazy_property
def calls(self):
return set(line.text.split('(',1)[0].split()[1].lower() for line in self.text if isinstance(line,Call))
############################################################
@irpy.lazy_property
def regexp(self):
import re
return re.compile(r"([^a-z0-9'\"_]|^)%s([^a-z0-9_]|$)" % (self.name), re.I)
############################################################
@irpy.lazy_property
def calls(self):
return set(
line.text.split('(', 1)[0].split()[1].lower() for line in self.text
if isinstance(line, Call))

2
src/templates/finalize.f90
View File

@ -7,7 +7,7 @@ SUBROUTINE irp_finalize_{id}
{#entity_array}
IF (ALLOCATED({name})) THEN
{name_root}_is_built = .FALSE.
! DEALLOCATE({name})
DEALLOCATE({name})
ENDIF
{/entity_array}
END SUBROUTINE irp_finalize_{id}

2
src/templates/irp_lock.f90
View File

@ -24,7 +24,7 @@ SUBROUTINE irp_lock_{.}(set)
CALL omp_unset_lock({.}_lock)
ENDIF
{?do_debug} CALL irp_leach(irp_here) {/do_debug}
{?do_debug} CALL irp_leave(irp_here) {/do_debug}
END SUBROUTINE irp_lock_{.}
{/entity}

151
src/templates/irp_stack.f90 Normal file
View File

@ -0,0 +1,151 @@
MODULE irp_stack_mod
INTEGER, PARAMETER :: STACKMAX=1000
CHARACTER*(128) ,allocatable :: irp_stack(:,:)
DOUBLE PRECISION ,allocatable :: irp_cpu(:,:)
INTEGER ,allocatable :: stack_index(:)
INTEGER :: nthread
CHARACTER*(128) :: white = ''
END MODULE
SUBROUTINE irp_stack_init
USE irp_stack_mod
IMPLICIT NONE
INTEGER :: ithread
{?do_openmp}
INTEGER, EXTERNAL :: omp_get_thread_num
INTEGER, EXTERNAL :: omp_get_max_threads
{/do_openmp}
INTEGER :: ierr
{^do_openmp}
ithread = 0
{:else}
ithread = omp_get_thread_num()
{/do_openmp}
{^do_openmp} !$OMP CRITICAL {/do_openmp}
IF (.NOT.ALLOCATED(stack_index) ) THEN
{^do_openmp}
nthread = 1
{:else}
nthread = omp_get_max_threads()
{/do_openmp}
{?do_memory}
print *, 'Allocating irp_stack(0:',STACKMAX,',0:',nthread,')'
print *, 'Allocating irp_cpu(0:',STACKMAX,',0:',nthread,')'
print *, 'Allocating stack_index(0:',nthread,')'
{/do_memory}
ALLOCATE ( irp_stack(0:STACKMAX, 0:nthread), &
irp_cpu(0:STACKMAX, 0:nthread), &
stack_index(0:nthread) )
IF (ierr /=0 ) THEN
print*, 'Failed Allocating irp_stack, irp_cpu, stack_index'
ENDIF
stack_index = 0
END IF
END SUBROUTINE
SUBROUTINE irp_enter_routine(irp_where)
USE irp_stack_mod
IMPLICIT NONE
CHARACTER*(*), INTENT(in) :: irp_where
INTEGER :: ithread
REAL :: cpu
{?do_openmp}
INTEGER, EXTERNAL :: omp_get_thread_num
{/do_openmp}
{^do_openmp}
ithread = 0
{:else}
ithread = omp_get_thread_num()
{/do_openmp}
stack_index(ithread) = min(stack_index(ithread)+1,STACKMAX)
irp_stack(stack_index(ithread),ithread) = irp_where
END SUBROUTINE irp_enter_routine
SUBROUTINE irp_enter(irp_where)
USE irp_stack_mod
IMPLICIT NONE
CHARACTER*(*), INTENT(in) :: irp_where
INTEGER :: ithread
{?do_openmp}
INTEGER, EXTERNAL :: omp_get_thread_num
{/do_openmp}
{^do_openmp}
ithread = 0
{:else}
ithread = omp_get_thread_num()
{/do_openmp}
print *, ithread, ':', white(1:stack_index(ithread))//'-> ', trim(irp_where)
CALL cpu_time(irp_cpu(stack_index(ithread),ithread))
END SUBROUTINE irp_enter
SUBROUTINE irp_leave(irp_where)
USE irp_stack_mod
IMPLICIT NONE
CHARACTER*(*), INTENT(in) :: irp_where
INTEGER :: ithread
REAL :: cpu
{?do_openmp}
INTEGER, EXTERNAL :: omp_get_thread_num
{/do_openmp}
{^do_openmp}
ithread = 0
{:else}
ithread = omp_get_thread_num()
{/do_openmp}
CALL cpu_time(cpu)
print *, ithread, ':', white(1:stack_index(ithread))//'<- ', &
trim(irp_stack(stack_index(ithread),ithread)), &
cpu - irp_cpu(stack_index(ithread),ithread)
stack_index(ithread) = max(0,stack_index(ithread)-1)
END SUBROUTINE irp_leave
SUBROUTINE irp_trace
USE irp_stack_mod
IMPLICIT NONE
INTEGER :: ithread
{?do_openmp}
INTEGER, EXTERNAL :: omp_get_thread_num
{/do_openmp}
INTEGER :: i
{^do_openmp}
ithread = 0
{:else}
ithread = omp_get_thread_num()
{/do_openmp}
print *, 'Stack trace: ', ithread
print *, '-------------------------'
DO i=1,stack_index(ithread)
print *, trim(irp_stack(i,ithread))
END DO
print *, '-------------------------'
END SUBROUTINE irp_trace

1
src/templates/module.f90
View File

@ -6,7 +6,6 @@
! DO NOT MODIFY IT BY HAND !
!-----------------------------------------------!
MODULE {name}
{#use}

7
src/templates/provider.f90
View File

@ -29,15 +29,16 @@ SUBROUTINE provide_{name}
{@last} {?do_task}!$OMP END TASKGROUP{/do_task} {/last}
{/l_children_static}
{#l_entity}
{?dim} CALL allocate_{name} {/dim}
{/l_entity}
CALL bld_{name}
{?do_debug} CALL irp_enter(irp_here) {/do_debug}
{?do_openmp}
ENDIF
CALL irp_lock_{name}(.FALSE.)
{/do_openmp}
{?do_debug} CALL irp_leave(irp_here) {/do_debug}
END SUBROUTINE provide_{name}

69
src/templates/writer.f90
View File

@ -1,69 +0,0 @@
SUBROUTINE write_{name}(irp_num)
USE {fmodule}
IMPLICIT NONE
CHARACTER*(*), INTENT(IN) :: irp_num
LOGICAL :: irp_is_open = .TRUE.
INTEGER :: irp_iunit = 9
{?do_debug}
CHARACTER*(7+{@size key=name/}),PARAMETER :: irp_here = 'writer_{name}'
{/do_debug}
{?do_debug} CALL irp_enter(irp_here) {/do_debug}
IF (.NOT.{same_as}_is_built) THEN
CALL provide_{same_as}
ENDIF
{children}
CALL write_{.}(irp_num)
{/children}
DO WHILE (irp_is_open)
irp_iunit = irp_inuit + 1
INQUIRE(UNIT=irp_inuit, OPENED=irp_is_open)
END DO
{#group_entity}
OPEN(UNIT=irp_inuit,file='irpf90_{name}_'//trim(irp_num),FROM='FORMATTED',STATUS='UNKNOWN',ACTION='WRITE')
WRITE(irp_inuit,*) {.}{dim}
CLOSE(irp_inuit)
{/group_entity}
{?do_debug} CALL irp_leave(irp_here) {/do_debug}
END SUBROUTINE write_{name}
SUBROUTINE read_{name}(irp_num)
USE {fmodule}
IMPLICIT NONE
CHARACTER*(*), INTENT(IN) :: irp_num
LOGICAL :: irp_is_open = .TRUE.
INTEGER :: irp_iunit = 9
{?do_debug}
CHARACTER*(5+{@size key=name/}),PARAMETER :: irp_here = 'read_{name}'
{/do_debug}
{?do_debug} CALL irp_enter(irp_here) {/do_debug}
DO WHILE (irp_is_open)
irp_iunit = irp_inuit + 1
INQUIRE(UNIT=irp_inuit, OPENED=irp_is_open)
END DO
{#group_entity}
OPEN(UNIT=irp_inuit,file='irpf90_{name}_'//trim(irp_num),FROM='FORMATTED',STATUS='UNKNOWN',ACTION='WRITE')
READ(irp_inuit,*) {name}{dim}
CLOSE(irp_inuit)
{/group_entity}
CALL touch_{name}
{?do_debug} CALL irp_leave(irp_here) {/do_debug}
END SUBROUTINE read_{name}

46
src/touches.py
View File

@ -24,30 +24,40 @@
# 31062 Toulouse Cedex 4
# scemama@irsamc.ups-tlse.fr
from irpf90_t import irp_id,irpdir
from irpf90_t import irp_id, irpdir
import os
from command_line import command_line
def create(modules,variables):
# (Dict[str,Module]. Dict[str, Variable]) -> None
'''Create the fortran90 finalize subroutine and the touched one'''
main_modules_name =[ m.name for m in modules.values() if m.is_main]
def create(modules, variables):
# (Dict[str,Module]. Dict[str, Variable]) -> None
'''Create the fortran90 finalize subroutine and the touched one'''
d_template_finalize = {'id':irp_id,
'use':[m.name for m in modules.values() if not m.is_main and m.has_irp_module],
'entity_array':
[{'name':e.name,'name_root':e.same_as} for e in variables.values() if e.fmodule not in main_modules_name and e.dim]}
main_modules_name = [m.name for m in modules.values() if m.is_main]
d_template_touch = {'do_debug': command_line.do_debug,
'entity':[e.d_touche_template for e in variables.values() if e.fmodule not in main_modules_name]}
import util
str_out = util.ashes_env.render('touch.f90', d_template_touch) + util.ashes_env.render('finalize.f90', d_template_finalize)
d_template_finalize = {
'id': irp_id,
'use': [m.name for m in modules.values() if not m.is_main and m.has_irp_module],
'entity_array': [{
'name': e.name,
'name_root': e.same_as
} for e in variables.values() if e.fmodule not in main_modules_name and e.dim]
}
d_template_touch = {
'do_debug': command_line.do_debug,
'entity': [
e.d_touche_template for e in variables.values()
if e.fmodule not in main_modules_name and e.d_touche_template
]
}
import util
str_out = util.ashes_env.render('touch.f90', d_template_touch) + util.ashes_env.render(
'finalize.f90', d_template_finalize)
filename = os.path.join(irpdir, 'irp_touches.irp.F90')
util.lazy_write_file(filename, '%s\n' % util.remove_empy_lines(str_out))
filename=os.path.join(irpdir,'irp_touches.irp.F90')
util.lazy_write_file(filename,'%s\n'% util.remove_empy_lines(str_out))
if __name__ == '__main__':
create()
create()

178
src/util.py
View File

@ -24,7 +24,6 @@
# 31062 Toulouse Cedex 4
# scemama@irsamc.ups-tlse.fr
# ~#~#~#~#~#
# L o g e r
# ~#~#~#~#~#
@ -42,30 +41,33 @@ logging.basicConfig(level=logging.INFO)
logger = logging.getLogger('Irpf90')
logger.setLevel(30)
# ~#~#~#~#~#
# A S H E S _ T E M P L A T E S
# ~#~#~#~#~#
from lib.manager import ashes
from lib.manager import ashes
import os
ashes_env = ashes.AshesEnv([os.path.join(os.path.dirname(__file__),'templates')])
ashes_env = ashes.AshesEnv([os.path.join(os.path.dirname(__file__), 'templates')])
def remove_empy_lines(text):
return os.linesep.join([s for s in text.splitlines() if s.strip()])
return os.linesep.join([s for s in text.splitlines() if s.strip()])
# ~#~#~#~#~#
# / / _ R E L A T E D
# ~#~#~#~#~#
def chunkify(l,n_chunk):
def chunkify(l, n_chunk):
# (List[any], int) -> List [ List[any] ]
'''Split the list on n_chunk'''
len_ = len(l)
n = max(1, len_ / n_chunk )
return [ l[i:i + n] for i in xrange(0, len_, n) ]
n = max(1, len_ / n_chunk)
return [l[i:i + n] for i in xrange(0, len_, n)]
import multiprocessing
def parmap(f, it, parallel=False):
# (Callable, Iterable, bool) -> List
'''Parallel version of the std map function
@ -81,7 +83,7 @@ def parmap(f, it, parallel=False):
'''
if not parallel:
return map(f, it)
return map(f, it)
nproc = multiprocessing.cpu_count()
@ -109,12 +111,12 @@ def parmap(f, it, parallel=False):
# In this implementation, we minimizise the communication
# (aka 1 job by processor)
it_chunk = chunkify(l=it,n_chunk=nproc)
it_chunk = chunkify(l=it, n_chunk=nproc)
def F(chunk):
# (List[any]) -> (List[any])
'''Same as 'f' but for a chunck'''
return map(f,chunk)
return map(f, chunk)
q_in = multiprocessing.JoinableQueue()
q_out = multiprocessing.Queue()
@ -123,8 +125,8 @@ def parmap(f, it, parallel=False):
stop_condition = None
def worker():
# () -> None
'''Read a task from q_in, excute it, and store it in q_out
# () -> None
'''Read a task from q_in, excute it, and store it in q_out
Note:
- We use 'F' and not 'f'.
@ -132,19 +134,19 @@ def parmap(f, it, parallel=False):
- We get, and put an idx to allow the possibility of ordering afterward
- We store any exeception, to raise her afterward
'''
for i, x in iter(q_in.get, stop_condition):
for i, x in iter(q_in.get, stop_condition):
try:
result = F(x)
except BaseException as e:
t = e
else:
t = (i, result)
try:
result = F(x)
except BaseException as e:
t = e
else:
t = (i, result)
q_out.put(t)
q_out.put(t)
q_in.task_done()
q_in.task_done()
q_in.task_done()
# Process' creation
l_proc = [multiprocessing.Process(target=worker) for _ in range(nproc)]
@ -154,7 +156,7 @@ def parmap(f, it, parallel=False):
# Add the job to the queue (Note we add an idx, this will all)
for i, x in enumerate(it_chunk):
q_in.put((i, x))
q_in.put((i, x))
# Now add the stop contidion and join
# (Because q_in.get is blocking we don't need to join the queue before)
@ -163,26 +165,28 @@ def parmap(f, it, parallel=False):
q_in.join()
# Get all the chunk and join the process
l_res = [q_out.get() for _ in range(len(it_chunk))]
l_res = [q_out.get() for _ in range(len(it_chunk))]
for p in l_proc:
p.join()
# Check if error have occured
try:
from itertools import ifilter
e = next(ifilter(lambda t: isinstance(t,BaseException), l_res))
from itertools import ifilter
e = next(ifilter(lambda t: isinstance(t, BaseException), l_res))
except StopIteration:
# Now we need first to order the result, and secondly to flatte it
return [item for _, chunk in sorted(l_res) for item in chunk]
# Now we need first to order the result, and secondly to flatte it
return [item for _, chunk in sorted(l_res) for item in chunk]
else:
raise e
raise e
# ~#~#~#~#~#
# I O _ R E L A T E D
# ~#~#~#~#~#
import hashlib
import os
def cached_file(filename, text):
# (str,str) -> bool
'''Check if file locatte at filename containt the same data as text
@ -192,19 +196,19 @@ def cached_file(filename, text):
'''
def digest(data):
# (str) -> str
'''compute an uniq data id'''
return hashlib.md5(data).hexdigest()
# (str) -> str
'''compute an uniq data id'''
return hashlib.md5(data).hexdigest()
try:
text_ref = open(filename, 'rb').read()
text_ref = open(filename, 'rb').read()
except IOError:
return False
else:
return digest(text_ref) == digest(text)
def lazy_write_file(filename, text, conservative=False,touch=False):
def lazy_write_file(filename, text, conservative=False, touch=False):
# (str, str, bool) -> None
'''Write data lazily in filename location.
@ -216,7 +220,8 @@ def lazy_write_file(filename, text, conservative=False,touch=False):
with open(filename, 'w') as f:
f.write(text)
elif touch:
os.utime(filename,None)
os.utime(filename, None)
def listdir(directory, abspath=False):
#(str, bool) -> List[str]
@ -228,6 +233,7 @@ def listdir(directory, abspath=False):
else:
return [os.path.abspath(os.path.join(directory, f)) for f in l_filename]
def check_output(*popenargs, **kwargs):
"""Run command with arguments and return its output as a byte string.
Backported from Python 2.7 as it's implemented as pure python on stdlib.
@ -252,28 +258,29 @@ def check_output(*popenargs, **kwargs):
# ~#~#~#~#~#
def uniquify(l,sort=False):
def uniquify(l, sort=False):
# (Iter, bool) -> List[Any]
'''Uniquify a immutable iterable. Don't preserve the order. Or maybe.'''
#Be carefull that element in Iter can be unshable.
try:
r = list(set(l))
r = list(set(l))
except TypeError:
used = list()
r = [x for x in l if x not in used and (used.append(x) or True)]
used = list()
r = [x for x in l if x not in used and (used.append(x) or True)]
if not sort:
return r
return r
else:
return sorted(r)
return sorted(r)
def OrderedUniqueList(l):
# (Iter, bool) -> List[Any]
'''Uniquify a immutable iterable. Don't preserve the order'''
return sorted(set(l))
def flatten(l_2d):
# (List [ Iter[Any] ]) -> List
'''Construct a copy of the 2d list collapsed into one dimension.
@ -289,25 +296,25 @@ def flatten(l_2d):
# I R P _ R E L A T E D
# ~#~#~#~#~#
def dimsize(x):
# (str) -> str
'''Compute the number of element in the array'''
try:
b0, b1 = x.split(':')
except ValueError:
return x
# (str) -> str
'''Compute the number of element in the array'''
try:
b0, b1 = x.split(':')
except ValueError:
return x
b0_is_digit = b0.replace('-', '').isdigit()
b1_is_digit = b1.replace('-', '').isdigit()
b0_is_digit = b0.replace('-', '').isdigit()
b1_is_digit = b1.replace('-', '').isdigit()
if b0_is_digit and b1_is_digit:
size = str(int(b1) - int(b0) + 1)
elif b0_is_digit:
size = "(%s) - (%d)" % (b1, int(b0) - 1)
elif b1_is_digit:
size = "(%d) - (%s)" % (int(b1) + 1, b0)
else:
size = "(%s) - (%s) + 1" % (b1, b0)
return size
if b0_is_digit and b1_is_digit:
size = str(int(b1) - int(b0) + 1)
elif b0_is_digit:
size = "(%s) - (%d)" % (b1, int(b0) - 1)
elif b1_is_digit:
size = "(%d) - (%s)" % (int(b1) + 1, b0)
else:
size = "(%s) - (%s) + 1" % (b1, b0)
return size
def build_dim(l_dim, colons=False):
@ -326,35 +333,37 @@ def build_dim(l_dim, colons=False):
return "(%s)" % (",".join(l_dim_colons))
def mangled(l_ent, d_ent):
# (List, Dict[str,Entity]) -> list
'''Create a uniq list of providier (merge the multione) '''
return OrderedUniqueList(d_ent[name].same_as for name in l_ent)
def build_use(l_ent, d_ent,use=True):
def build_use(l_ent, d_ent, use=True):
# (List, Dict[str,Entity]) -> list
'''Contruct the fortran90 'use' statement for the list of entity'''
l_name = OrderedUniqueList(d_ent[x].fmodule for x in l_ent)
if not use:
return l_name
return l_name
else:
return [" use %s" % n for n in l_name]
return [" use %s" % n for n in l_name]
def build_call_provide(l_ent, d_ent):
# (List, Dict[str,Entity]) -> list
'''Construct the fortran 90 call the provider needed by the list of entity'''
# Get the corect name (in the case of multiple provider line)
l_same_as = mangled(l_ent,d_ent)
l_same_as = mangled(l_ent, d_ent)
def bld_f90(x):
return [ " if (.not.%s_is_built) then" % x,
" call provide_%s" % x,
" endif"]
return [" if (.not.%s_is_built) then" % x, " call provide_%s" % x, " endif"]
return flatten(map(bld_f90, l_same_as))
def che_merge(sets):
#(List[Set] -> List[Set]
"""Merge a list of set is they are not disjoint.
@ -364,25 +373,32 @@ def che_merge(sets):
results = []
upd, isd, pop = set.update, set.isdisjoint, sets.pop
while sets:
if not [upd(sets[0],pop(i)) for i in range(len(sets)-1,0,-1) if not isd(sets[0],sets[i])]:
if not [
upd(sets[0], pop(i)) for i in range(len(sets) - 1, 0, -1)
if not isd(sets[0], sets[i])
]:
results.append(pop(0))
return results
def l_dummy_entity(d_entity):
# Dict[str:Entity] -> List[set]
from itertools import combinations
l_candidate_botom = [ (i,j) for i,j in combinations(d_entity.keys(),2) if d_entity[i].needs == d_entity[j].needs]
l_dummy = [set([i,j]) for i,j in l_candidate_botom if d_entity[i].needed_by == d_entity[j].needed_by]
# Dict[str:Entity] -> List[set]
from itertools import combinations
l_candidate_botom = [(i, j) for i, j in combinations(d_entity.keys(), 2)
if d_entity[i].needs == d_entity[j].needs]
l_dummy = [
set([i, j]) for i, j in l_candidate_botom if d_entity[i].needed_by == d_entity[j].needed_by
]
return che_merge(l_dummy)
return che_merge(l_dummy)
def split_l_set(l_set_org):
#(List[set] -> (List, Set)
'''Split the list of set into a list of Head and and the concetenad of all the tail
#(List[set] -> (List, Set)
'''Split the list of set into a list of Head and and the concetenad of all the tail
Note: Head and Tail a not defined in set. Head in one element of the set, and tail the rest.
'''
l_set = [set(s) for s in l_set_org]
l_main = [ s.pop() for s in l_set]
return l_main, set(flatten(l_set))
l_set = [set(s) for s in l_set_org]
l_main = [s.pop() for s in l_set]
return l_main, set(flatten(l_set))

35
src/vim.py
View File

@ -24,25 +24,26 @@
# 31062 Toulouse Cedex 4
# scemama@irsamc.ups-tlse.fr
import os
def install():
VIM = os.environ["HOME"]+"/.vim"
try:
if os.access(VIM+"/syntax/irpf90.vim",os.F_OK):
return
if not os.access(VIM,os.F_OK):
os.mkdir(VIM)
file = open(VIM+"/filetype.vim","a")
file.write("au BufRead,BufNewFile *.irp.f setfiletype irpf90")
file.close()
if not os.access(VIM+"/syntax",os.F_OK):
os.mkdir(VIM+"/syntax")
wd = os.path.abspath(os.path.dirname(__file__))
os.symlink(wd+"/irpf90.vim",VIM+"/syntax/irpf90.vim")
except:
pass
VIM = os.environ["HOME"] + "/.vim"
try:
if os.access(VIM + "/syntax/irpf90.vim", os.F_OK):
return
if not os.access(VIM, os.F_OK):
os.mkdir(VIM)
file = open(VIM + "/filetype.vim", "a")
file.write("au BufRead,BufNewFile *.irp.f setfiletype irpf90")
file.close()
if not os.access(VIM + "/syntax", os.F_OK):
os.mkdir(VIM + "/syntax")
wd = os.path.abspath(os.path.dirname(__file__))
os.symlink(wd + "/irpf90.vim", VIM + "/syntax/irpf90.vim")
except:
pass
if __name__ == "__main__":
install()
install()