def __init__(self, ip, port):
self.ip = ip
self.port = port
self.buffsize = 2048**2
self.main_socket = s.socket(s.AF_INET, s.SOCK_STREAM) # Create socketTCP
###
self.main_socket.setsockopt(s.SOL_SOCKET, s.SO_REUSEADDR, self.port)
###
self.main_socket.bind((self.ip, self.port))
self.main_socket.listen(5)
self.server_is_open = True # is the game server on?
self.games = [] # list of on-going games
self.names = {} # dictionary of client and his game name
self.timers = {} # dictionary of each game and its time state (True/False) {Game:T/F}
self.question_start_time = {} # dictionary of {Game:current_question_start_time}
self.wall_displays = {} # dictionary of all wall display sockets and their games {socket:Game}
self.next_question_request = [] # list of wall displays that requested a next question (for a specific round)
self.validated = {} # dictionary of clients and their validated games
self.validated_login = {} # dictionary of validated username and password clients, values: T/number of failed logins
self.messages = {} # {socket:[messages],...}
self.inputs = [self.main_socket]
self.outputs = []
self.connected = {} # dictionary of connected clients (including clients not in games) {clientobj:(Game, player_name),...}
self.m = Module() # module object for database interaction
def insertDeviceModules(moduleList, annotateParentsOnly=False):
elabAreaConstraints = AreaConstraints(moduleList)
# this was constructed upon the original call to load area.
elabAreaConstraints.loadAreaConstraintsElaborated()
for userAreaGroup in elabAreaConstraints.constraints.values():
if('SYNTH_BOUNDARY' in userAreaGroup.attributes):
# Modify parent to know about this child.
parentModule = moduleList.modules[userAreaGroup.parentName]
# pick up deps from parent.
moduleDeps ={}
moduleName = userAreaGroup.attributes['MODULE_NAME']
# grab the parent module verilog and convert it. This
# is really ugly, and demonstrates whe first class
# language constructs are so nice. Eventually, we
# should push these new synth boundary objects into
# flow earlier.
moduleVerilog = None
for dep in map(functools.partial(bsv_tool.modify_path_ba, moduleList), model.convertDependencies(moduleList.getAllDependenciesWithPaths('GEN_VERILOGS'))):
if (re.search(moduleName, dep)):
moduleVerilog = dep
if(moduleVerilog is None):
print "ERROR: failed to find verilog for area group: " + userAreaGroup.name
exit(1)
moduleVerilogBlackBox = moduleVerilog.replace('.v', '_stub.v')
moduleDeps['GEN_VERILOG_STUB'] = [moduleVerilogBlackBox]
# We need to ensure that the second pass glue logic
# modules don't look at the black box stubs. The modules
# are in the current synth boundaries list, but not in the LI graph.
parentList = [parentModule, moduleList.topModule] + [module for module in moduleList.synthBoundaries() if not module.name in elabAreaConstraints.constraints]
for parent in parentList:
print "BLACK_BOX Annotating: " + parent.name
if(parent.getAttribute('BLACK_BOX') is None):
parent.putAttribute('BLACK_BOX', {moduleVerilog: moduleVerilogBlackBox})
else:
blackBoxDict = parent.getAttribute('BLACK_BOX')
blackBoxDict[moduleVerilog] = moduleVerilogBlackBox
if(not annotateParentsOnly):
moduleList.env.Command([moduleVerilogBlackBox], [moduleVerilog],
'leap-gen-black-box -nohash $SOURCE > $TARGET')
m = Module(userAreaGroup.name, [moduleName],\
parentModule.buildPath, parentModule.name,\
[], parentModule.name, [], moduleDeps)
m.putAttribute("WRAPPER_NAME", moduleName)
m.putAttribute("AREA_GROUP", 1)
moduleList.insertModule(m)
def __init__(self):
#contructor
#model inherits from the module class
Module.__init__(self)
#the model is constitued of 2 linear layer with activation layer
self.l1 = Sequential(Linear(2, 16), ReLu(), Linear(16, 92))
self.s1 = TanhS()
self.l2 = Linear(92, 2)
def main():
opts = optparser.parse_args()[0]
train_loader = Loader(opts.train)
opts.vocab_len = len(train_loader._char_to_id)
opts.pos_len = len(train_loader._pos_to_id)
opts.max_pos_len = train_loader._pos_max_len
opts.max_target_len = train_loader._char_max_len
opts.use_cuda = opts.use_cuda == 1
opts.eval = opts.eval == 1
opts.data_size = train_loader.get_data_size()
if not torch.cuda.is_available():
opts.use_cuda = False
torch.manual_seed(opts.seed)
np.random.seed(opts.seed)
if not opts.eval:
# weights for paddings, set to 0
loss_weights = torch.ones(opts.vocab_len)
loss_weights[0] = 0
criterion = nn.NLLLoss(loss_weights, size_average=False)
c2i, i2c, p2i, i2p = train_loader.get_mappings()
dev_loader = Loader(opts.dev, c2i, i2c, p2i, i2p)
if dev_loader._pos_max_len > opts.max_pos_len:
opts.max_pos_len = dev_loader._pos_max_len
model = Module(opts)
if opts.model_path is not '':
model = torch.load(opts.model_path)
train_batcher = Batcher(opts.batch_size, train_loader.get_data(),
opts.max_pos_len, opts.eval)
dev_batcher = Batcher(decode_batch, dev_loader.get_data(),
opts.max_pos_len, True)
print model
start_train(model, criterion, opts, train_batcher, dev_batcher)
else:
model = torch.load(opts.model_path)
model.eval()
#print model
c2i, i2c, p2i, i2p = train_loader.get_mappings()
test_loader = Loader(opts.test, c2i, i2c, p2i, i2p)
if test_loader._pos_max_len > opts.max_pos_len:
opts.max_pos_len = test_loader._pos_max_len
test_batcher = Batcher(1, test_loader.get_data(), opts.max_pos_len,
opts.eval)
opts.data_size = test_loader.get_data_size()
decode(model, opts, test_batcher, i2c, i2p)
def load_modules():
"""Load modules data to database."""
print "Modules"
# delete modules before data gets added to avoid duplicate info
# Module.query.delete()
# insert data from seed_module
with open("seed_data/seed_module") as module_data:
for row in module_data:
name, description, additional_info, user_id = row.rstrip().split(
"|")
module = Module(name=name,
description=description,
additional_info=additional_info,
user_id=user_id)
# add module to session
db.session.add(module)
# commit changes
db.session.commit()
print "Modules loaded."
def add_modules(username):
"""Add function/module information"""
if not verify_user(username):
return redirect("/login")
mname = request.form.get("mname")
mdesc = request.form.get("mdesc")
maddinfo = request.form.get("maddinfo")
fname = request.form.get("fname")
fdesc = request.form.get("fdesc")
faddinfo = request.form.get("faddinfo")
samplecode = request.form.get("samplecode")
output = request.form.get("output")
if fname == "":
flash("Please input a function name.")
return redirect("/{}/addmodules".format(username))
# fetch user to get user_id
user = User.query.filter_by(username=username).first()
existing_mod = Module.query.filter(
(Module.user_id == user.user_id) | (Module.user_id == 1),
Module.name == mname).first()
if mname == "":
module = Module.query.filter_by(module_id=1).first()
elif existing_mod:
module = existing_mod
else:
module = Module(name=mname,
description=mdesc,
additional_info=maddinfo,
user_id=user.user_id)
db.session.add(module)
db.session.commit()
function = Function(name=fname,
description=fdesc,
additional_info=faddinfo,
sample_code=samplecode,
output=output,
user_id=user.user_id,
module_id=module.module_id)
db.session.add(function)
db.session.commit()
flash("Your notes have been added.")
return redirect("/{}/studynotes".format(username))
def __getitem__(self, idx):
return (self.x[idx], self.t[idx], idx)
# ===================================================================================================== #
batch_size = {'train': 32, 'valid': 32}
dataloader = {
phase:
torch.utils.data.DataLoader(dataset=SrDataset(phase, dire, width, height),
batch_size=batch_size[phase],
shuffle=False)
for phase in ['valid']
}
use_gpu = torch.cuda.is_available()
module = Module()
module.load_state_dict(torch.load(pretrained))
fid = open('parameters', 'wb+')
for param in module.parameters():
b = param.data.numpy()
fid.write(b)
fid.close()
if use_gpu:
module.cuda()
module = nn.DataParallel(module, gpu)
for stage in ([0] * 1):
# for epoch in range(1):
for phase in ["valid"]:
def __init__(self, moduleList):
TMP_BSC_DIR = moduleList.env['DEFS']['TMP_BSC_DIR']
topModulePath = get_build_path(moduleList, moduleList.topModule)
# The LIM compiler uniquifies synthesis boundary names
uidOffset = int(moduleList.getAWBParam('wrapper_gen_tool', 'MODULE_UID_OFFSET'))
# We only inject the platform wrapper in first pass builds. In
# the second pass, we import the first pass object code. It may
# be that we need this code?
# Inject a synth boundary for platform build code. we need to
# pick up some dependencies from the top level code. this is a
# pretty major hack, in my opinion. Better would be to actually
# inspect the eventual .ba files for their dependencies.
platformName = moduleList.localPlatformName + '_platform'
platformDeps = {}
platformDeps['GEN_VERILOGS'] = []
platformDeps['GEN_BAS'] = [] #moduleList.getSynthBoundaryDependencies(moduleList.topModule, 'GEN_BAS')
platformDeps['GEN_VPI_HS'] = moduleList.getSynthBoundaryDependencies(moduleList.topModule, 'GEN_VPI_HS')
platformDeps['GEN_VPI_CS'] = moduleList.getSynthBoundaryDependencies(moduleList.topModule, 'GEN_VPI_CS')
#This is sort of a hack.
platformDeps['GIVEN_BSVS'] = []
platformDeps['WRAPPER_BSHS'] = ['awb/provides/virtual_platform.bsh', 'awb/provides/physical_platform.bsh']
platformDeps['BA'] = []
platformDeps['STR'] = []
platformDeps['VERILOG'] = [topModulePath + '/' + TMP_BSC_DIR + '/mk_' + platformName + '_Wrapper.v']
platformDeps['BSV_LOG'] = []
platformDeps['VERILOG_STUB'] = []
platform_module = Module( platformName, ["mkVirtualPlatform"], moduleList.topModule.buildPath,\
moduleList.topModule.name,\
[], moduleList.topModule.name, [], platformDeps, platformModule=True)
platform_module.dependsFile = '.depends-platform'
platform_module.interfaceType = 'VIRTUAL_PLATFORM'
platform_module.extraImports = ['virtual_platform']
first_pass_LI_graph = getFirstPassLIGraph()
if(first_pass_LI_graph is None):
moduleList.insertModule(platform_module)
moduleList.graphize()
moduleList.graphizeSynth()
# Sprinkle more files expected by the two-pass build.
generateWrapperStub(moduleList, platform_module)
generateAWBCompileWrapper(moduleList, platform_module)
else:
platform_module_li = first_pass_LI_graph.modules[moduleList.localPlatformName + '_platform']
# This gives us the right path.
synthHandle = getSynthHandle(moduleList, platform_module)
# throw in some includes...
synthHandle.write('import HList::*;\n')
synthHandle.write('import Vector::*;\n')
synthHandle.write('import ModuleContext::*;\n')
synthHandle.write('import GetPut::*;\n')
synthHandle.write('import Clocks::*;\n')
synthHandle.write('`include "awb/provides/virtual_platform.bsh"\n')
synthHandle.write('`include "awb/provides/physical_platform.bsh"\n')
generateWellKnownIncludes(synthHandle)
# May need an extra import here?
# get the platform module from the LIGraph
generateBAImport(platform_module_li, synthHandle)
# include synth stub here....
_emitSynthModule(platform_module_li, synthHandle, platform_module.interfaceType,
localPlatformName = moduleList.localPlatformName)
## Here we use a module list sorted alphabetically in order to guarantee
## the generated wrapper files are consistent. The topological sort
## guarantees only a depth first traversal -- not the same traversal
## each time.
synth_modules = [moduleList.topModule] + moduleList.synthBoundaries()
## Models have the option of declaring top-level clocks that will
## be exposed as arguments. When top-level clocks exist a single
## top-level reset is also defined. To request no top-level clocks
## the variable N_TOP_LEVEL_CLOCKS should be removed from a platform's
## AWB configuration file, since Bluespec can't test the value of
## a preprocessor variable.
try:
n_top_clocks = int(moduleList.getAWBParam('physical_platform', 'N_TOP_LEVEL_CLOCKS'))
if (n_top_clocks == 0):
sys.stderr.write("Error: N_TOP_LEVEL_CLOCKS may not be 0 due to Bluespec preprocessor\n")
sys.stderr.write(" limitations. To eliminate top-level clocks, remove the AWB\n")
sys.stderr.write(" parameter from the platform configuration.\n")
sys.exit(1)
except:
n_top_clocks = 0
for module in synth_modules:
modPath = moduleList.env['DEFS']['ROOT_DIR_HW'] + '/' + module.buildPath + '/' + module.name
wrapperPath = modPath + "_Wrapper.bsv"
logPath = modPath + "_Log.bsv"
conSizePath = modPath + "_Wrapper_con_size.bsh"
ignorePath = moduleList.env['DEFS']['ROOT_DIR_HW'] + '/' + module.buildPath + '/.ignore'
# clear out code on clean.
if moduleList.env.GetOption('clean'):
os.system('rm -f ' + wrapperPath)
os.system('rm -f ' + logPath)
os.system('rm -f ' + conSizePath)
os.system('rm -f ' + ignorePath)
if (module.name != moduleList.topModule.name):
os.system('rm -f ' + modPath + '.bsv')
continue
if (model.getBuildPipelineDebug(moduleList) != 0):
print "Wrapper path is " + wrapperPath
wrapper_bsv = open(wrapperPath, 'w')
ignore_bsv = open(ignorePath, 'w')
ignore_bsv.write("// Generated by wrapper_gen.py\n\n")
# Connection size doesn't appear on the first dependence pass, since it
# doesn't exist until after the first build. Finding it later results in
# build dependence changes and rebuilding. Ignore it, since the file will
# change only when some other file changes.
ignore_bsv.write(conSizePath)
ignore_bsv.close()
# Generate a dummy connection size file to avoid errors during dependence
# analysis.
if not os.path.exists(conSizePath):
dummyModule = LIModule(module.name, module.name)
bsh_handle = open(conSizePath, 'w')
generateConnectionBSH(dummyModule, bsh_handle)
bsh_handle.close()
wrapper_bsv.write('import HList::*;\n')
wrapper_bsv.write('import Vector::*;\n')
wrapper_bsv.write('import ModuleContext::*;\n')
# the top module is handled specially
if (module.name == moduleList.topModule.name):
generateWellKnownIncludes(wrapper_bsv)
wrapper_bsv.write('// These are well-known/required leap modules\n')
wrapper_bsv.write('// import non-synthesis public files\n')
# Include all subordinate synthesis boundaries for use by
# instantiateAllSynthBoundaries() below.
# If we're doing a LIM build, there are no *_synth.bsv for use codes.
# Probably if we're doing a build tree they aren't necessary either, but
# removing those dependencies would take a little work.
if(first_pass_LI_graph is None):
for synth in synth_modules:
if synth != module:
wrapper_bsv.write('`include "' + synth.name + '_synth.bsv"\n')
# Provide a method that imports all subordinate synthesis
# boundaries. It will be invoked inside the top level model
# in order to build all soft connections
use_build_tree = moduleList.getAWBParam('wrapper_gen_tool', 'USE_BUILD_TREE')
expose_all_connections = 0
try:
expose_all_connections = moduleList.getAWBParam('model', 'EXPOSE_ALL_CONNECTIONS')
except:
pass
if (use_build_tree == 1):
wrapper_bsv.write('\n\n`ifdef CONNECTION_SIZES_KNOWN\n');
# build_tree.bsv will get generated later, during the
# leap-connect phase.
wrapper_bsv.write(' import build_tree_synth::*;\n');
wrapper_bsv.write(' module [Connected_Module] instantiateAllSynthBoundaries#(Reset baseReset) ();\n')
wrapper_bsv.write(' Reset rst <- mkResetFanout(baseReset);\n')
wrapper_bsv.write(' let m <- build_tree(baseReset, reset_by rst);\n')
wrapper_bsv.write(' endmodule\n')
wrapper_bsv.write('`else\n');
wrapper_bsv.write('\n module ')
if len(synth_modules) != 1:
wrapper_bsv.write('[Connected_Module]')
wrapper_bsv.write(' instantiateAllSynthBoundaries#(Reset baseReset) ();\n')
for synth in synth_modules:
if synth != module and not synth.platformModule:
wrapper_bsv.write(' ' + synth.synthBoundaryModule + '();\n')
wrapper_bsv.write(' endmodule\n')
if (use_build_tree == 1):
wrapper_bsv.write('`endif\n');
# Import platform wrapper.
wrapper_bsv.write(' import ' + moduleList.localPlatformName +'_platform_synth::*;\n');
wrapper_bsv.write(' module [Connected_Module] instantiatePlatform ('+ platform_module.interfaceType +');\n')
wrapper_bsv.write(' let m <- ' + moduleList.localPlatformName + '_platform(noReset);\n')
wrapper_bsv.write(' return m;\n')
wrapper_bsv.write(' endmodule\n')
wrapper_bsv.write('`include "' + module.name + '.bsv"\n')
wrapper_bsv.write('\n// import non-synthesis private files\n')
wrapper_bsv.write('// Get defintion of TOP_LEVEL_WIRES\n')
wrapper_bsv.write('import physical_platform::*;\n')
wrapper_bsv.write('(* synthesize *)\n')
wrapper_bsv.write('module [Module] mk_model_Wrapper\n')
wrapper_bsv.write(' (TOP_LEVEL_WIRES);\n\n')
wrapper_bsv.write(' // Instantiate main module\n')
wrapper_bsv.write(' let m <- mkModel(clocked_by noClock, reset_by noReset);\n')
wrapper_bsv.write(' return m;\n')
wrapper_bsv.write('endmodule\n')
else:
log_bsv = open(logPath, 'w')
log_bsv.write('import HList::*;\n')
log_bsv.write('import ModuleContext::*;\n')
# Parents of a synthesis boundary likely import the top level module of
# the boundary. This way, the synthesis boundary could be removed and
# the code within the boundary would be imported correctly by the parent.
# The code within the synthesis boundary will actually be imported at the
# top level instead, so we need a dummy module for use by the parent of
# a boundary that looks like it imports the code but actually does nothing.
# Importing at the top level allows us to build all synthesis regions
# in parallel.
dummy_import_bsv = open(modPath + '.bsv', 'w')
dummy_import_bsv.write('// Generated by wrapper_gen.py\n\n')
dummy_import_bsv.write('module ' + module.synthBoundaryModule + ' ();\n');
dummy_import_bsv.write('endmodule\n');
dummy_import_bsv.close()
if not os.path.exists(modPath + '_synth.bsv'):
dummy_module = LIModule(module.name, module.name)
handle = getSynthHandle(moduleList, module)
generateSynthWrapper(dummy_module, handle, moduleList.localPlatformName,
moduleType = module.interfaceType,
extraImports = module.extraImports)
for wrapper in [wrapper_bsv, log_bsv]:
wrapper.write('// These are well-known/required leap modules\n')
generateWellKnownIncludes(wrapper)
wrapper.write('`include "awb/provides/librl_bsv_base.bsh"\n')
wrapper.write('// import non-synthesis public files\n')
wrapper.write('`include "' + module.name + '_compile.bsv"\n')
wrapper.write('\n\n')
log_bsv.write('// First pass to see how large the vectors should be\n')
log_bsv.write('`define CON_RECV_' + module.boundaryName + ' 100\n')
log_bsv.write('`define CON_SEND_' + module.boundaryName + ' 100\n')
log_bsv.write('`define CON_RECV_MULTI_' + module.boundaryName + ' 50\n')
log_bsv.write('`define CON_SEND_MULTI_' + module.boundaryName + ' 50\n')
log_bsv.write('`define CHAINS_' + module.boundaryName + ' 50\n')
wrapper_bsv.write('// Real build pass. Include file built dynamically.\n')
wrapper_bsv.write('`include "' + module.name + '_Wrapper_con_size.bsh"\n')
for wrapper in [wrapper_bsv, log_bsv]:
wrapper.write('(* synthesize *)\n')
wrapper.write('module [Module] ' + module.wrapperName() + '#(Reset baseReset) (SOFT_SERVICES_SYNTHESIS_BOUNDARY#(`CON_RECV_' + module.boundaryName + ', `CON_SEND_' + module.boundaryName + ', `CON_RECV_MULTI_' + module.boundaryName + ', `CON_SEND_MULTI_' + module.boundaryName +', `CHAINS_' + module.boundaryName +', ' + module.interfaceType + '));\n')
wrapper.write(' \n')
# we need to insert the fpga platform here
# get my parameters
wrapper.write(' // instantiate own module\n')
wrapper.write(' let int_ctx0 <- initializeServiceContext();\n')
wrapper.write(' match {.int_ctx1, .int_name1} <- runWithContext(int_ctx0, putSynthesisBoundaryID(fpgaNumPlatforms() + ' + str(module.synthBoundaryUID + uidOffset) + '));\n');
wrapper.write(' match {.int_ctx2, .int_name2} <- runWithContext(int_ctx1, putSynthesisBoundaryPlatform("' + moduleList.localPlatformName + '"));\n')
wrapper.write(' match {.int_ctx3, .int_name3} <- runWithContext(int_ctx2, putSynthesisBoundaryPlatformID(' + str(moduleList.localPlatformUID) + '));\n')
wrapper.write(' match {.int_ctx4, .int_name4} <- runWithContext(int_ctx3, putSynthesisBoundaryName("' + str(module.boundaryName) + '"));\n')
wrapper.write(' // By convention, global string ID 0 (the first string) is the module name\n');
wrapper.write(' match {.int_ctx5, .int_name5} <- runWithContext(int_ctx4, getGlobalStringUID("' + moduleList.localPlatformName + ':' + module.name + '"));\n');
wrapper.write(' match {.int_ctx6, .module_ifc} <- runWithContext(int_ctx5, ' + module.synthBoundaryModule + ');\n')
# Need to expose clocks of the platform Module
if(module.platformModule):
wrapper.write(' match {.clk, .rst} = extractClocks(module_ifc);\n')
wrapper.write(' match {.int_ctx7, .int_name7} <- runWithContext(int_ctx6, mkSoftConnectionDebugInfo(clocked_by clk, reset_by rst));\n')
wrapper.write(' match {.final_ctx, .m_final} <- runWithContext(int_ctx7, mkSoftConnectionLatencyInfo(clocked_by clk, reset_by rst));\n')
else:
wrapper.write(' match {.int_ctx7, .int_name7} <- runWithContext(int_ctx6, mkSoftConnectionDebugInfo);\n')
wrapper.write(' match {.final_ctx, .m_final} <- runWithContext(int_ctx7, mkSoftConnectionLatencyInfo);\n')
wrapper.write(' let service_ifc <- exposeServiceContext(final_ctx);\n')
wrapper.write(' interface services = service_ifc;\n')
wrapper.write(' interface device = module_ifc;\n')
wrapper.write('endmodule\n')
log_bsv.close()
wrapper_bsv.close()
def setupTreeBuild(self, moduleList, topo):
useBVI = self.parent.USE_BVI
env = moduleList.env
root_directory = model.rootDir
##
## Load intra-Bluespec dependence already computed. This
## information will ultimately drive the building of Bluespec
## modules. Build tree has a few dependencies which must be
## captured.
##
## If we aren't building the build tree, don't bother with its dependencies
env.ParseDepends(get_build_path(moduleList, moduleList.topModule) + '/.depends-build-tree',
must_exist = not moduleList.env.GetOption('clean'))
tree_base_path = env.Dir(get_build_path(moduleList, moduleList.topModule))
tree_file_synth = tree_base_path.File('build_tree_synth.bsv')
tree_file_synth_bo_path = tree_base_path.File(self.parent.TMP_BSC_DIR + '/build_tree_synth.bo')
tree_file_wrapper = tree_base_path.File('build_tree_Wrapper.bsv')
tree_file_wrapper_bo_path = tree_base_path.File(self.parent.TMP_BSC_DIR + '/build_tree_Wrapper.bo')
# Area constraints
area_constraints = None
try:
if (moduleList.getAWBParam('area_group_tool', 'AREA_GROUPS_ENABLE')):
area_constraints = area_group_tool.AreaConstraints(moduleList)
except:
# The area constraints code is not present.
pass
boundary_logs = []
for module in topo:
# Remove any platform modules.. These are special in that
# they can have wired interfaces.
if (not module.platformModule):
for log in module.moduleDependency['BSV_LOG']:
boundary_logs += [root_directory.File(log)]
##
## Back to SCons configuration (first) pass...
##
top_module_path = get_build_path(moduleList, moduleList.topModule)
# Inform object code build of the LI Graph retrieved from the
# first pass. Probe firstPassGraph for relevant object codes
# (BA/NGC/BSV_SYNTH/BSV_SYNTH_BSH) accessed:
# module.objectCache['NGC'] (these already have absolute
# paths) I feel like the GEN_BAS/GEN_VERILOGS of the first
# pass may be missing. We insert these modules as objects in
# the ModuleList.
def makeAWBLink(doLink, source, buildPath, uniquifier=''):
base_file = os.path.basename(str(source))
link_dir = buildPath + '/.li'
link_path = link_dir + '/' + uniquifier + base_file
if (doLink):
if (os.path.lexists(link_path)):
os.remove(link_path)
rel = os.path.relpath(str(source), link_dir)
print 'Linking: ' + link_path + ' -> ' + rel
os.symlink(rel, link_path)
return link_path
limLinkUserSources = []
limLinkUserTargets = []
limLinkPlatformSources = []
limLinkPlatformTargets = []
importStubs = []
if (not self.getFirstPassLIGraph is None):
# Now that we have demanded bluespec builds (for
# dependencies), we should now should downgrade synthesis boundaries for the backend.
oldStubs = []
for module in topo:
if(not module.platformModule):
if((not module.name in self.getFirstPassLIGraph.modules) or (self.getFirstPassLIGraph.modules[module.name].getAttribute('RESYNTHESIZE') is None)):
module.liIgnore = True
# this may not be needed.
else:
oldStubs += module.moduleDependency['GEN_VERILOG_STUB']
# let's pick up the platform dependencies, since they are also special.
env.ParseDepends(get_build_path(moduleList, moduleList.topModule) + '/.depends-platform',
must_exist = not moduleList.env.GetOption('clean'))
# Due to the way that string files are
# generated, they are difficult to rename in
# the front-end compilation. This leads to
# collisions amoung similarly-typed LI
# Modules. We fix it by uniquifying the links.
def getModuleName(module):
return module.name
def getEmpty(module):
return ''
linkthroughMap = {'BA': getEmpty, 'GEN_BAS': getEmpty, 'GEN_VERILOGS': getEmpty, 'GEN_VERILOG_STUB': getEmpty, 'STR': getModuleName}
buildPath = get_build_path(moduleList, moduleList.topModule)
for module in self.getFirstPassLIGraph.modules.values():
# do not link through those modules marked for resynthesis.
if(not module.getAttribute('RESYNTHESIZE') is None):
continue
moduleDeps = {}
for objType in linkthroughMap:
if(objType in module.objectCache):
localNames = map(lambda fileName: makeAWBLink(False,
fileName.from_bld(),
buildPath,
uniquifier=linkthroughMap[objType](module)),
module.objectCache[objType])
# The previous passes GEN_VERILOGS are not
# really generated here, so we can't call them
# as such. Tuck them in to 'VERILOG'
if(objType == 'GEN_VERILOG_STUB'):
oldStubs += localNames
moduleDeps[objType] = localNames
if (module.getAttribute('PLATFORM_MODULE') is None):
limLinkUserTargets += localNames
limLinkUserSources += module.objectCache[objType]
else:
limLinkPlatformTargets += localNames
limLinkPlatformSources += module.objectCache[objType]
m = Module(module.name, ["mk_" + module.name + "_Wrapper"],\
moduleList.topModule.buildPath, moduleList.topModule.name,\
[], moduleList.topModule.name, [], moduleDeps)
moduleList.insertModule(m)
else:
# The top module/build pipeline only depend on non-platformModules
oldStubs = [module.moduleDependency['GEN_VERILOG_STUB'] for module in moduleList.synthBoundaries() if not module.platformModule]
## Enumerate the dependencies created by the build tree.
buildTreeDeps = {}
## We have now generated a completely new module. Let's throw it
## into the list. Although we are building it seperately, this
## module is an extension to the build tree.
expected_wrapper_count = len(boundary_logs) - 2
importBOs = []
if (not self.getFirstPassLIGraph is None):
# we now have platform modules in here.
expected_wrapper_count = len(self.getFirstPassLIGraph.modules) - 2
# If we have an LI graph, we need to construct and compile
# LI import wrappers for the modules we received from the
# first pass. Do that here. include all the dependencies
# in the graph in the wrapper.
liGraph = LIGraph([])
firstPassGraph = self.getFirstPassLIGraph
# We should ignore the 'PLATFORM_MODULE'
liGraph.mergeModules([ module for module in bsv_tool.getUserModules(firstPassGraph) if module.getAttribute('RESYNTHESIZE') is None])
for module in sorted(liGraph.graph.nodes(), key=lambda module: module.name):
# pull in the dependecies generate by the dependency pass.
env.ParseDepends(str(tree_base_path) + '/.depends-' + module.name,
must_exist = not moduleList.env.GetOption('clean'))
wrapper_path = tree_base_path.File(module.name + '_Wrapper.bsv')
wrapper_bo_path = tree_base_path.File(self.parent.TMP_BSC_DIR + '/' + module.name + '_Wrapper.bo')
# include commands to build the wrapper .bo/.ba
# Here, we won't be using the generated .v (it's garbage), so we intentionally get rid of it.
importVDir = env.Dir('.lim_import_verilog')
if not os.path.isdir(str(importVDir)):
os.mkdir(str(importVDir))
wrapper_command = self.parent.compile_bo_bsc_base([wrapper_bo_path], get_build_path(moduleList, moduleList.topModule), vdir=importVDir) + ' $SOURCES'
wrapper_bo = env.Command([wrapper_bo_path],
[wrapper_path],
wrapper_command)
# create BO.
importBOs += [wrapper_bo]
verilog_deps = [ "__TREE_MODULE__" + str(id) for id in range(expected_wrapper_count)]
if(self.parent.BUILD_LOGS_ONLY == 0):
buildTreeDeps['GEN_VERILOGS'] = ["mk_" + vlog + '_Wrapper' + ".v" for vlog in verilog_deps]
else:
buildTreeDeps['GEN_VERILOGS'] = []
buildTreeDeps['GEN_BAS'] = [ "mk_" + vlog + '_Wrapper' + ".ba" for vlog in verilog_deps]
buildTreeDeps['BA'] = []
buildTreeDeps['STR'] = []
buildTreeDeps['VERILOG'] = [top_module_path + '/' + self.parent.TMP_BSC_DIR + '/mk_build_tree_Wrapper.v']
buildTreeDeps['GIVEN_BSVS'] = []
buildTreeDeps['VERILOG_STUB'] = model.convertDependencies(oldStubs)
tree_module = Module( 'build_tree', ["mkBuildTree"], moduleList.topModule.buildPath,\
moduleList.topModule.name,\
[], moduleList.topModule.name, [], buildTreeDeps, platformModule=True)
tree_module.putAttribute('LI_GRAPH_IGNORE', True)
moduleList.insertModule(tree_module)
wrapper_gen_tool.generateAWBCompileWrapper(moduleList, tree_module)
## This produces the treeNode BSV. It must wait for the
## compilation of the log files, which it will read to form the
## LIM graph
##
## We do two operations during this phase. First, we dump a
## representation of the user program. This representation is
## used by the LIM compiler to create heterogeneous
## executables. We then do a local modification to the build
## tree to reduce Bluespec compilation time.
# If I got an LI graph, I don't care about the boundary logs.
# In this case, everything comes from the first pass graph.
# Usually, we only need logs and BOs to build the build tree.
# However, during the second pass build we also need to fill
# in information about area group paths (changed by tree build)
tree_build_deps = boundary_logs + importBOs
tree_build_results = [tree_file_wrapper, tree_file_synth]
if (self.getFirstPassLIGraph and area_constraints):
tree_build_deps += [area_constraints.areaConstraintsFilePlaced()]
tree_build_results += [area_constraints.areaConstraintsFile()]
##
## The cutTreeBuild builder function needs some of the local state
## in the current function. Build a dictionary with the required
## state and partial instance of cutTreeBuild with the state applied.
##
cut_tree_state = dict()
cut_tree_state['area_constraints'] = area_constraints
cut_tree_state['boundary_logs'] = boundary_logs
cut_tree_state['moduleList'] = moduleList
cut_tree_state['tree_file_synth'] = tree_file_synth
cut_tree_state['tree_file_wrapper'] = tree_file_wrapper
cut_tree_build = functools.partial(self.cutTreeBuild, cut_tree_state)
cut_tree_build.__name__ = 'cutTreeBuild'
tree_components = env.Command(tree_build_results,
tree_build_deps,
cut_tree_build)
## Compiling the build tree wrapper produces several .ba
## files, some that are useful, the TREE_MODULES, and some
## which are not, the _Wrapper.ba. As a result, we dump the
## tree build output to a different directory, so as not to
## pollute the existing build. Here, we link to the relevant
## files in that directory.
def linkLIMObjClosure(liModules, buildPath):
def linkLIMObj(target, source, env):
if (not self.getFirstPassLIGraph is None):
# The LIM build has passed us some source and we need
# to patch it through.
for module in liModules:
for objType in linkthroughMap:
if(objType in module.objectCache):
map(lambda fileName: makeAWBLink(True, fileName.from_bld(), buildPath, uniquifier=linkthroughMap[objType](module)),
module.objectCache[objType])
return linkLIMObj
## The top level build depends on the compilation of the tree components
## into bo/ba/v files.
# the GEN_BAS attached to the build tree need to be massaged
# to reflect their actual path. Perhaps we should be using
# some kind of object that makes these sorts of conversions
# simpler.
producedBAs = map(lambda path: bsv_tool.modify_path_ba(moduleList, path), moduleList.getModuleDependenciesWithPaths(tree_module, 'GEN_BAS'))
producedVs = map(lambda path: bsv_tool.modify_path_ba(moduleList, path), moduleList.getModuleDependenciesWithPaths(tree_module, 'GEN_VERILOGS')) + \
buildTreeDeps['VERILOG']
tree_command = self.parent.compile_bo_bsc_base([tree_file_wrapper_bo_path], get_build_path(moduleList, moduleList.topModule)) + ' ' + tree_file_wrapper.path
tree_file_wrapper_bo = env.Command([tree_file_wrapper_bo_path] + producedBAs + producedVs,
tree_components,
tree_command)
# If we got a first pass LI graph, we need to link its object codes.
if (not self.getFirstPassLIGraph is None):
srcs = [s.from_bld() for s in limLinkUserSources]
link_lim_user_objs = env.Command(limLinkUserTargets,
srcs,
linkLIMObjClosure([ module for module in bsv_tool.getUserModules(firstPassGraph) if module.getAttribute('RESYNTHESIZE') is None],
tree_base_path.path))
env.Depends(link_lim_user_objs, tree_file_wrapper_bo)
# the tree_file_wrapper build needs all the wrapper bo from the user program,
# but not the top level build.
top_bo = moduleList.topModule.moduleDependency['BSV_BO']
all_bo = moduleList.getAllDependencies('BO')
env.Depends(tree_file_wrapper_bo, all_bo)
tree_synth_command = self.parent.compile_bo_bsc_base([tree_file_synth_bo_path], get_build_path(moduleList, moduleList.topModule)) + ' ' + tree_file_synth.path
tree_file_synth_bo = env.Command([tree_file_synth_bo_path],
[tree_file_synth, tree_file_wrapper_bo],
tree_synth_command)
env.Depends(top_bo, tree_file_synth_bo)
env.Depends(moduleList.topModule.moduleDependency['BSV_LOG'],
tree_file_synth_bo)
#Handle the platform_synth build, which is special cased.
platform_synth = get_build_path(moduleList, moduleList.topModule) + "/" + moduleList.localPlatformName + "_platform_synth.bsv"
platform_synth_bo_path = get_build_path(moduleList, moduleList.topModule) + "/" + self.parent.TMP_BSC_DIR +"/" + moduleList.localPlatformName + "_platform_synth"
# if we are in the lim linking phase, we need to change the
# vdir directory to hide the spurious verilog generated by
# bluespec.
importVDir = None
if(not self.getFirstPassLIGraph is None):
importVDir = env.Dir('.lim_import_verilog')
if not os.path.isdir(str(importVDir)):
os.mkdir(str(importVDir))
platform_synth_command = self.parent.compile_bo_bsc_base([platform_synth_bo_path + '.bo'], get_build_path(moduleList, moduleList.topModule), vdir=importVDir) + ' $SOURCE'
platform_wrapper_bo = get_build_path(moduleList, moduleList.topModule) + "/" + self.parent.TMP_BSC_DIR + "/" +moduleList.localPlatformName + '_platform_Wrapper.bo'
platform_synth_deps = [platform_synth]
#if we have a module graph, we don't require the compilation of the platform_wrapper_bo.
if (self.getFirstPassLIGraph is None):
platform_synth_deps.append(platform_wrapper_bo)
platform_synth_bo = env.Command([platform_synth_bo_path + '.bo'],
platform_synth_deps,
platform_synth_command)
# this produces a ba also?
env.Depends(moduleList.topModule.moduleDependency['BSV_LOG'],
platform_synth_bo)
# Platform synth does the same object-bypass dance as tree_module.
if(not self.getFirstPassLIGraph is None):
srcs = [s.from_bld() for s in limLinkPlatformSources]
link_lim_platform_objs = env.Command(limLinkPlatformTargets,
srcs,
linkLIMObjClosure([ module for module in bsv_tool.getPlatformModules(firstPassGraph) if module.getAttribute('RESYNTHESIZE') is None],
tree_base_path.path))
env.Depends(link_lim_platform_objs, platform_synth_bo)
# need to generate a stub file for the build tree module.
# note that in some cases, there will be only one module in
# the graph, usually in a multifpga build. In this case,
# the build_tree module will be vestigal, but since we can't
# predict this statically we'll have to build it anyway.
tree_module.moduleDependency['GEN_VERILOG_STUB'] = [self.parent.stubGenCommand(top_module_path,
"build_tree",
top_module_path + '/' + self.parent.TMP_BSC_DIR + "/mk_build_tree_Wrapper.v")]
# top level only depends on platform modules
moduleList.topModule.moduleDependency['VERILOG_STUB'] = model.convertDependencies([module.moduleDependency['GEN_VERILOG_STUB'] for module in moduleList.synthBoundaries() if module.platformModule])
if(not self.getFirstPassLIGraph is None):
#Second pass build picks up stub files from the first pass build.
moduleList.topModule.moduleDependency['VERILOG_STUB'] += model.convertDependencies(oldStubs)
class ModuleTests(unittest.TestCase):
def setUp(self):
self.m = Module()
def tearDown(self):
pass
def depth(self):
return len(self.m.cells)
def width(self):
return len(self.m.cells[0])
def createGridAndTieCell0Input(self,
wIn,
wOut,
width,
depth=1,
initValForCell0=False):
self.m.createGrid(wIn, wOut, width, depth)
self.m.tieCell0([initValForCell0])
def testInit4x1(self):
self.createGridAndTieCell0Input(4, 4, 4, 1)
self.assertTrue(self.depth() == 1)
self.assertTrue(self.width() == 4)
def testInitNxN(self):
self.createGridAndTieCell0Input(7, 7, 7, 6)
self.assertTrue(self.depth() == 6)
self.assertTrue(self.width() == 7)
def test2x1AndTiedLow(self):
self.createGridAndTieCell0Input(2, 2, 2, 1)
self.m.driveInputs([True, True])
self.assertEqual(self.m.sampleOutputs(), [False, False])
def test2x1AndTiedHigh(self):
self.createGridAndTieCell0Input(2, 2, 2, 1, True)
self.m.driveInputs([True, True])
self.assertEqual(self.m.sampleOutputs(), [True, True])
def test3x1AndTiedHigh(self):
self.createGridAndTieCell0Input(3, 3, 3, 1, True)
self.m.driveInputs([True, True, False])
self.assertEqual(self.m.sampleOutputs(), [True, True, False])
def test2x2AndTiedHigh(self):
self.createGridAndTieCell0Input(2, 2, 2, 2, True)
self.m.driveInputs([True, True])
self.assertEqual(self.m.sampleOutputs(), [True, True])
self.m.driveInputs([True, False])
self.assertEqual(self.m.sampleOutputs(), [False, False])
def test3x2AndTiedHigh(self):
self.createGridAndTieCell0Input(3, 3, 3, 2, True)
self.m.driveInputs([True, True, True])
self.assertEqual(self.m.sampleOutputs(), [True, True, True])
self.m.driveInputs([True, False, True])
self.assertEqual(self.m.sampleOutputs(), [False, False, False])
def testFixNumberOfFlopsTo0(self):
self.createGridAndTieCell0Input(25, 25, 25, 14, True)
self.m.setNumFlops(0)
self.assertTrue(self.m.getNumFlops() == 0)
def testFixNumberOfFlopsToLtWidth(self):
self.createGridAndTieCell0Input(25, 25, 25, 14, True)
self.m.setNumFlops(17)
self.assertTrue(self.m.getNumFlops() == 17)
def testFixNumberOfFlopsToGtWidth(self):
self.createGridAndTieCell0Input(25, 25, 25, 14, True)
self.m.setNumFlops(28)
self.assertTrue(self.m.getNumFlops() == 28)
def testFixNumberOfFlopsToMax(self):
self.createGridAndTieCell0Input(25, 25, 25, 14, True)
self.m.setNumFlops(25 * 14)
self.assertTrue(self.m.getNumFlops() == (25 * 14))
def test2x1FloppedAndTiedHigh(self):
self.createGridAndTieCell0Input(2, 2, 2, 1, True)
self.m.setNumFlops(2)
self.m.driveInputs([True, True])
self.m.clk()
self.assertEqual(self.m.sampleOutputs(), [True, False])
self.m.clk()
self.assertEqual(self.m.sampleOutputs(), [True, True])
def testOutputMuxOnlyExistsWhenOutputSmallerThanInputWidth(self):
self.createGridAndTieCell0Input(2, 2, 2)
self.assertEqual(self.m.outputMux, None)
def testOutputMuxForMoreInputsThanOutputs(self):
self.createGridAndTieCell0Input(2, 1, 2)
self.assertNotEqual(self.m.outputMux, None)
def testOutputSizeFor2Inputs1Output(self):
self.createGridAndTieCell0Input(2, 1, 2)
self.m.driveInputs([True, True])
self.assertEqual(len(self.m.sampleOutputs()), 1)
def testOutputFor2Inputs1Output(self):
self.createGridAndTieCell0Input(2, 1, 2, 1, True)
self.m.driveInputs([True, True])
self.assertEqual(self.m.sampleOutputs(), [True])
def testOutputFor3Inputs2Output(self):
self.createGridAndTieCell0Input(3, 2, 3, 1, True)
self.m.driveInputs([True, True, False])
self.assertEqual(self.m.sampleOutputs(), [True, False])
def testOutputFor4Inputs3Output(self):
self.createGridAndTieCell0Input(4, 3, 4, 1, True)
self.m.driveInputs([True, True, True, False])
self.assertEqual(self.m.sampleOutputs(), [True, True, False])
def testOutputFor5Inputs4Output(self):
self.createGridAndTieCell0Input(5, 4, 5, 1, True)
self.m.driveInputs([True, True, True, False, False])
self.assertEqual(self.m.sampleOutputs(), [True, True, False, False])
def testOutputFor8Inputs5Output(self):
self.createGridAndTieCell0Input(8, 5, 8, 1, True)
self.m.driveInputs([True] * 6 + [False, False])
self.assertEqual(self.m.sampleOutputs(),
[True, True, True, False, False])
def testModuleHasFixedCells(self):
self.createGridAndTieCell0Input(2, 2, 2)
self.m.setNumFlops(2)
self.m.driveInputs([True] * 2)
self.m.clk()
self.m.sampleOutputs()
self.m.clk()
self.m.sampleOutputs()
self.assertTrue(self.m.moduleHasFixedCells())
def testModuleHasNoFixedCells(self):
self.createGridAndTieCell0Input(2, 2, 2, 1, True)
self.m.cells[0][1].setOutputType(OutputType.sync)
self.m.driveInputs([True] * 2)
self.m.clk()
self.m.sampleOutputs()
self.m.driveInputs([False] * 2)
self.m.clk()
self.m.sampleOutputs()
self.assertFalse(self.m.moduleHasFixedCells())
def testOutputHistory(self):
self.createGridAndTieCell0Input(2, 2, 2, 1, True)
self.m.driveInputs([True, True])
self.m.sampleOutputs()
self.m.sampleOutputs()
self.m.sampleOutputs()
self.assertEqual(len(self.m.outputHistory()), 3)
self.assertEqual(self.m.outputHistory(),
[[True, True], [True, True], [True, True]])
self.assertTrue(self.m.outputsFixed())
def testOutputsNotFixed(self):
self.createGridAndTieCell0Input(2, 2, 2, 1, True)
self.m.driveInputs([True, True])
self.m.sampleOutputs()
self.m.driveInputs([False, False])
self.m.sampleOutputs()
self.assertFalse(self.m.outputsFixed())
def testOutputFor1Input2Outputs(self):
self.createGridAndTieCell0Input(1, 2, 2, 1, True)
self.m.driveInputs([True])
self.assertEqual(self.m.sampleOutputs(), [True, True])
def testOutputFor2Input4Outputs(self):
self.createGridAndTieCell0Input(2, 4, 4, 1, True)
self.m.driveInputs([True, True])
self.assertEqual(self.m.sampleOutputs(), [True, True] * 2)
def testOutputForLargerGridWidth(self):
self.createGridAndTieCell0Input(2, 4, 6, 1, True)
self.m.driveInputs([True, True])
self.assertEqual(self.m.sampleOutputs(), [True, True] * 2)
def setUp(self):
self.cycles = 100
self.m = Module()
class GameServer(object):
def __init__(self, ip, port):
self.ip = ip
self.port = port
self.buffsize = 2048**2
self.main_socket = s.socket(s.AF_INET, s.SOCK_STREAM) # Create socketTCP
###
self.main_socket.setsockopt(s.SOL_SOCKET, s.SO_REUSEADDR, self.port)
###
self.main_socket.bind((self.ip, self.port))
self.main_socket.listen(5)
self.server_is_open = True # is the game server on?
self.games = [] # list of on-going games
self.names = {} # dictionary of client and his game name
self.timers = {} # dictionary of each game and its time state (True/False) {Game:T/F}
self.question_start_time = {} # dictionary of {Game:current_question_start_time}
self.wall_displays = {} # dictionary of all wall display sockets and their games {socket:Game}
self.next_question_request = [] # list of wall displays that requested a next question (for a specific round)
self.validated = {} # dictionary of clients and their validated games
self.validated_login = {} # dictionary of validated username and password clients, values: T/number of failed logins
self.messages = {} # {socket:[messages],...}
self.inputs = [self.main_socket]
self.outputs = []
self.connected = {} # dictionary of connected clients (including clients not in games) {clientobj:(Game, player_name),...}
self.m = Module() # module object for database interaction
@staticmethod
def get_current_time():
return time.clock()
@staticmethod
def run_command(cmd):
"""
Spawn new processes, connect to their input/output/error pipes, and obtain their return codes
arg: cmd
arg type: string
ret type: string
"""
return subprocess.Popen(cmd,
shell=True, # not recommended, but does not open a window
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
stdin=subprocess.PIPE).communicate()
@staticmethod
def get_host_ip():
"""
:return: the computer's ip address
"""
ip = GameServer.run_command('ipconfig /all')[0].split("\n")
for i in ip:
if 'IPv4 Address' in i and '(Preferred)' in i:
ip = i.split()[-1]
ip = ip[0:ip.find('(')]
break
else:
ip = 'localhost' # no specific address was found use localhost
return ip
@staticmethod
def get_open_ports():
'''
:return: first open port number
'''
sock = s.socket(s.AF_INET, s.SOCK_STREAM)
sock.bind(("", 0))
sock.listen(1)
port = sock.getsockname()[1]
sock.close()
return port
@staticmethod
def update_host_and_port(host, port):
try:
print 'Updating Server information on Kahoot_db Server...\r\nKahoot_play Server at:\r\nHost: %s; Port: %d' \
% (host, port)
result = kht.update(name='YuvalStein', ip=host, port=port)
if result['status'] == 'OK':
print 'Information updated successfully.'
else:
print(result['status'])
raise result['status']
except Exception as e:
print e
print 'Connection to kahoot_db Server failed, Please manually update the client.'
def handle_game(self):
while self.inputs and self.server_is_open:
readables, writeables, exceptions = select(self.inputs, self.outputs, [])
for sockobj in readables:
if sockobj is self.main_socket:
clientobj, addr = self.main_socket.accept()
print 'connected from', addr
self.inputs.append(clientobj)
self.outputs.append(clientobj)
self.messages[clientobj] = [] # this is where the clients messages will be saved
self.connected[clientobj] = None # client not in game currently
else:
# Client socket
data = None
try:
data = sockobj.recv(self.buffsize) # receive the data the client sent
print 'Got', (data), 'on', id(sockobj)
except Exception as e:
print e
if not data: # close connection
self.inputs.remove(sockobj)
self.outputs.remove(sockobj)
del self.connected[sockobj]
# client exits in the middle of the game
if sockobj in self.validated:
game = self.validated[sockobj]
player_name = self.names[sockobj]
del game.players[player_name]
if len(game.players) < 2:
for socketobj, player in self.names.items():
if player != player_name:
self.add_data(socketobj, ['error', 'Not enough players in game.'])
for socketobj, _game in self.wall_displays.items():
if _game == game and sockobj != socketobj:
self.add_data(socketobj, ['error', 'Not enough players in game.'])
del self.validated[sockobj]
del self.names[sockobj]
if game in self.games:
del self.games[self.games.index(game)]
if sockobj in self.validated_login and self.validated_login[sockobj] is True:
del self.validated_login[sockobj]
# wall clients
if sockobj in self.wall_displays:
game = self.wall_displays[sockobj]
del self.wall_displays[sockobj]
# disconnect players
for socketobj in self.names: # inform all connected players that game is over
if socketobj in self.validated and self.validated[socketobj] == game:
self.add_data(socketobj, ['error', 'Wall Display died.'])
if game in self.games:
del self.games[self.games.index(game)]
if sockobj in self.next_question_request:
del self.next_question_request[self.next_question_request.index(sockobj)]
# update everyone with the information
self.send_all_data()
else: # handle data
num = 0
prev_index = 0
tmp_data = ""
orig_data = data
for i in range(len(orig_data)):
if orig_data[i] == '[':
num += 1
elif orig_data[i] == ']':
num -= 1
if num == 0:
if prev_index == 0:
tmp_data = orig_data[:i + 1]
else:
tmp_data = orig_data[prev_index:i + 1]
data = eval(tmp_data)
self.handle_data(data, sockobj)
prev_index = i + 1
self.send_all_data()
# self.server_is_open = False:
self.close_clients()
self.close()
def handle_data(self, data, sockobj):
if data[0] == 'close_server':
self.server_is_open = False
elif data[0] == 'wall_display':
if data[1] == 'start_update': # get important data in the beginning of the game
self.get_connected_players(sockobj)
elif data[1] == 'game_update':
if data[2] == 'first_question':
game = self.wall_displays[sockobj]
game.started = True # update boolean 'started'
self.timers[game] = True
self.question_start_time[game] = self.get_current_time()
# information for wall display
info = ['wall_display', 'game_update', 'first_question'] + self.get_current_question_info(sockobj)
self.add_data(sockobj, info)
# information for all the connected clients to this game (possible answers list)
current_answers = game.get_current_answers()
for clientobj in self.connected:
# if client is in the same game of the wall display
if self.connected[clientobj] and self.connected[clientobj][0] == self.wall_displays[sockobj]:
# send the client the current answers
self.add_data(clientobj, ['game', 'answers'] + current_answers)
elif data[2] == 'game_update':
self.get_number_of_answers(sockobj) # returns the current question and the number of answers
elif data[2] == 'round_results':
self.timers[self.wall_displays[sockobj]] = False
self.get_round_info(sockobj)
self.next_question_request = []
elif data[1] == 'next_question':
if sockobj not in self.next_question_request:
game = self.wall_displays[sockobj]
self.timers[game] = True
self.question_start_time[game] = self.get_current_time()
game.player_answers = {} # new round of answers
game.current_question += 1 # update question number
info = ['wall_display', 'next_question'] + self.get_current_question_info(sockobj)
self.next_question_request.append(sockobj)
self.add_data(sockobj, info)
# information for all the connected clients to this game (possible answers list)
current_answers = game.get_current_answers()
for clientobj in self.connected:
# if client is in the same game of the wall display
if self.connected[clientobj] and self.connected[clientobj][0] == self.wall_displays[sockobj]:
# send the client the current answers
info = ['game', 'answers'] + current_answers
self.add_data(clientobj, info)
elif data[1] == 'end_questionnaire': # game ended
self.timers[self.wall_displays[sockobj]] = False
self.end_game(sockobj)
else: # unknown data
pass
elif data[0] == 'game':
if data[1] == 'answer':
player_name = data[3]
# check if player already gave an answer or question time is over
if self.timers[self.validated[sockobj]]: # don't take answer if question time is up
if player_name not in self.validated[sockobj].player_answers or \
not self.validated[sockobj].player_answers[player_name]:
self.update_player_answer(sockobj, data[2], player_name)
elif data[0] == 'join':
if data[1] == 'validate':
self.validate_game(sockobj, data[2], data[3])
else: # player wants to join a game
if sockobj in self.validated and self.validated[sockobj]: # final validation
self.join_game(sockobj, self.validated[sockobj], data[1])
# if first player connected set automatic timer (if requested for game)
if len(self.validated[sockobj].players) == 1 and \
not self.validated[sockobj].wait_for_players:
self.timers[self.validated[sockobj]] = ('Start', self.get_current_time())
elif data[0] == 'login':
login_request = data[1]
if login_request == 'login': # user wants to login
self.validate_login(sockobj, data[2], data[3])
elif login_request == 'get_all_kahoots':
self.add_data(sockobj, ['login', 'get_all_kahoots'] + self.m.get_all_questionnaries())
elif login_request == 'get_my_kahoots':
self.add_data(sockobj, ['login', 'get_my_kahoots'] + self.m.get_user_questionnaires(data[2]))
elif login_request == 'host_game':
self.open_new_game(sockobj, data[2])
else: # create new game (not to play right now)
self.create_new_game(sockobj, data[2], data[3], data[4], data[5])
elif data[0] == 'sign_up':
self.add_new_user(sockobj, data[1], data[2])
else: # invalid request
self.add_data(sockobj, 'Invalid request')
def initiate(self):
self.main_socket.bind((self.ip, self.port))
self.main_socket.listen(4)
def add_data(self, socketobj, data):
if type(data) != list:
data = [data]
self.messages[socketobj] += data
def send_all_data(self):
for socketobj in self.messages:
if self.messages[socketobj]:
data = str(self.messages[socketobj])
try:
socketobj.send(data)
except:
pass
# delete the sent data
self.messages[socketobj] = []
def validate_game(self, socketobj, game_name, game_pin):
game = None
info = None
for g in self.games:
# if game name and pin are correct, and the game hasn't started yet then joining is valid
if str(g.name) == str(game_name) and str(g.pin) == str(game_pin):
if not g.started:
self.validated[socketobj] = g # validate game for client
game = g
else:
info = 'game in progress, no more new players accepted'
if game and not info:
self.add_data(socketobj, ['join', 'request', True])
else:
self.add_data(socketobj, ['join', 'request', False])
if not info:
info = "couldn't find requested game, please check the name and pin."
data = [{'join': info}]
self.add_data(socketobj, data)
def validate_login(self, socketobj, username, password):
correct_password = self.m.get_user_password(username)
if correct_password and correct_password == password: # correct password was entered
self.validated_login[socketobj] = True
self.add_data(socketobj, ['login', 'login', True]) # return client successful login
elif not correct_password: # no such user in database
self.add_data(socketobj, ['login', 'login', False, 'User not found'])
else:
self.validated_login[socketobj] = self.validated_login[socketobj] + 1 if socketobj in self.validated_login \
else 1 # number of unsuccessful login attempts
self.add_data(socketobj, ['login', 'login', False]) # return client unsuccessful
def create_new_game(self, socketobj, publisher, game_name, questions_and_answers, correct_answers_and_times):
result = self.m.add_new_questionnaire(publisher, game_name, questions_and_answers, correct_answers_and_times)
if result:
self.add_data(socketobj, 'successfully added new questionnaire')
else:
self.add_data(socketobj, "couldn't add the questionnaire because name is not unique, "
"please choose a different name.")
def open_new_game(self, socketobj, game_name):
print 'Opening new game...'
game_pin = random.randrange(10**5, 10**6) # game_pin is a random number between 100000 and 999999
print 'Game Name: ',game_name,'; Game Pin:', game_pin
game = Game(game_name, game_pin)
self.games.append(game)
self.wall_displays[socketobj] = game
game.match_question_and_answer(self.m.get_questions_and_answers(game_name)) # update game questions
# timing settings
time_settings = eval(self.m.get_time_settings(game_name)) # dictionary of time settings
game.wait_for_players = time_settings['wait_for_players']
game.interval_between_questions = time_settings['interval']
# get starting info and update the wall display
self.add_data(socketobj, ['login', 'host_game', game_pin, game.wait_for_players, game.interval_between_questions])
def join_game(self, socketobj, game, player_name):
if player_name not in game.players:
game.players[player_name] = 0 # every player starts with 0 points
self.names[socketobj] = player_name
self.connected[socketobj] = (game, player_name) # save the player and the game he is connected to
self.add_data(socketobj, ['join', True, player_name,
'Successfully added to game!\r\nWaiting for more players...'])
else:
self.add_data(socketobj, ['join', False, player_name, 'Name already taken, please choose a different name'])
def get_connected_players(self, socketobj):
game = self.wall_displays[socketobj]
players_in_game = str(game.players)
self.add_data(socketobj, ['wall_display', 'start_update', players_in_game])
def get_number_of_answers(self, socketobj):
game = self.wall_displays[socketobj]
all_answers = len(game.player_answers)
self.add_data(socketobj, ['wall_display', 'game_update', 'game_update', str(all_answers)])
def get_round_info(self, socketobj):
game = self.wall_displays[socketobj]
# change the current question and immediately return to what it was before,
# in order to check if their is a next question
game.current_question += 1
if game.get_current_question() == [None]: # last question
info = ['wall_display', 'game_update', 'round_results', game.get_game_scores(), True]
else: # their is another question after this one
info = ['wall_display', 'game_update', 'round_results', game.get_game_scores(), False]
game.current_question -= 1
self.add_data(socketobj, info)
# update all the connected clients if they were right or wrong, and give them their scores.
for clientobj in self.connected:
# if client is in the same game of the wall display
if self.connected[clientobj] and self.connected[clientobj][0] == game:
# send the client the current answers
player_name = self.names[clientobj]
if player_name in game.player_answers:
client_answer = game.player_answers[player_name] in game.correct_answers[game.current_question]
else:
client_answer = False
points = game.players[player_name]
self.add_data(clientobj, ['game', 'round_results', client_answer, points])
def update_player_answer(self, socketobj, answer, player_name):
game = self.validated[socketobj]
correct_answer = game.correct_answers[game.current_question]
# single answer or multiple correct answers
if (type(correct_answer) == str and answer == correct_answer) or (answer in correct_answer):
points = self.calculate_points(True, self.question_start_time[game], self.get_current_time(),
game.times[game.current_question])
if player_name in game.correct_player_answers:
game.correct_player_answers[player_name] += 1
else: # first correct answer for player
game.correct_player_answers[player_name] = 1
else:
points = self.calculate_points(False)
game.update_player_and_points(player_name, points)
game.player_answers[player_name] = answer # player gave an answer, don't allow more
def calculate_points(self, answer, start_time=None, time=None, question_time=None):
if not answer: # if answer was incorrect don't give the player any points
return 0
time_left = question_time - (time - start_time)
return int(100*(time_left/question_time))
def get_current_question_info(self, socketobj):
game = self.wall_displays[socketobj]
all_answers = len(game.player_answers)
info = [str(all_answers)] + game.get_current_question()
return info
def add_new_user(self, socketobj, username, password):
result = self.m.add_user(username, password)
if result == 'user added successfully':
self.add_data(socketobj, ['sign_up', True])
else: # username taken
result += "Please enter a different username."
self.add_data(socketobj, ['sign_up', False, result])
def message_all_game_participants(self, game, message):
# message clients
for sockobj in self.validated:
if self.validated[sockobj] == game:
self.add_data(sockobj, message)
# message all wall display clients
for sockobj in self.wall_displays:
if self.wall_displays[sockobj] == game:
self.add_data(sockobj, message)
def client_score(self, client):
return self.validated[client].players[self.names[client]]
def end_game(self, socketobj):
game = self.wall_displays[socketobj]
game.ended = True
info = ['wall_display', 'end_questionnaire', game.get_winners()]
self.add_data(socketobj, info)
#self.save_game(game) # if game ended and more than 2 players where in it, save the game
# send players their places
clients = []
for clientobj in self.connected:
# if client is in the same game of the wall display
if self.connected[clientobj] and self.connected[clientobj][0] == game:
clients.append(clientobj)
clients = sorted(clients, key=self.client_score, reverse=True)
for i in range(len(clients)):
player_name = self.names[clients[i]]
points = game.players[player_name]
self.add_data(clients[i], ['game', 'final_results', i+1, points])
def save_game(self, game):
if len(game.players) >= 2 and game.ended:
self.m.add_questionnaire(self.m.get_all_info(game.name)[0][0], self.m.get_all_info(game.name)[0][1],
self.m.get_all_info(game.name)[0][2], game.players,
self.m.get_all_info(game.name)[0][-3])
def close_clients(self):
print 'Sending Shut-Down'
for client in self.connected:
client.send(str(['server_down']))
def close(self):
self.main_socket.close()
return (self.x[idx], self.t[idx], idx)
batch_sz = {'train': 12, 'valid': 10}
dataloader = {
phase:
torch.utils.data.DataLoader(dataset=SrDataset(phase, width, height,
img_dir),
batch_size=batch_sz[phase],
shuffle=True)
for phase in ['train', 'valid']
}
use_gpu = torch.cuda.is_available()
module = Module()
if pretrained is None:
for param in module.parameters():
print(param.size())
param.data.normal_(0.001, 0.05)
else:
module.load_state_dict(torch.load(pretrained))
if use_gpu:
module.cuda()
#module = nn.DataParallel(module, gpu)
# print(module)
loss = nn.MSELoss()
optimizer = torch.optim.Adam(module.parameters(), lr=1)
def setUp(self):
self.m = Module()
User(name='Bob Tan',
username='******',
password=
'******'
), # temp_pass
User(name='Mr. GovTech',
username='******',
password=
'******'
), # govtech_strong_password
User(name='Admin',
username='******',
password=
'******'
), # super_duper_whitehacks_strong_password
Module(code='IS200', name='Software Foundations'),
Module(code='IS103', name='Computational Thinking'),
Module(code='IS101', name='Seminar on Information Systems'),
Module(code='WRIT001', name='Academic Writing'),
Lesson(module_code='IS200', name='Lesson 01'),
Lesson(module_code='IS103', name='Lesson 01'),
Lesson(module_code='IS101', name='Lesson 01'),
Lesson(module_code='WRIT001', name='Lesson 01'),
Document(
lesson_id=1,
name='Document 01',
is_draft=False,
content=
'Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum'
),
Document(lesson_id=4,
class ModuleTests(unittest.TestCase):
def setUp(self):
self.cycles = 100
self.m = Module()
def tearDown(self):
pass
def depth(self):
return len(self.m.cells)
def width(self):
return len(self.m.cells[0])
def createGridAndTieCell0Input(self,
inWidth,
outWidth,
gridWidth,
d,
v=False):
self.m.createGrid(inWidth, outWidth, gridWidth, d)
self.m.tieCell0([v])
def gatesPruned(self, inWidth, outWidth, gridWidth, depth, flops):
self.createGridAndTieCell0Input(inWidth, outWidth, gridWidth, depth,
True)
self.m.setNumFlops(flops)
self.m.randomizeGates()
for i in range(self.cycles):
a = []
for i in range(inWidth):
a.append(random.getrandbits(1))
self.m.driveInputs(a)
self.m.clk()
self.m.sampleOutputs()
return self.m.outputsFixed() or self.m.moduleHasFixedCells()
def __init__(self, moduleList):
# some definitions used during the bsv compilation process
env = moduleList.env
self.moduleList = moduleList
self.hw_dir = env.Dir(moduleList.env['DEFS']['ROOT_DIR_HW'])
self.TMP_BSC_DIR = env['DEFS']['TMP_BSC_DIR']
synth_modules = moduleList.synthBoundaries()
self.USE_TREE_BUILD = moduleList.getAWBParam('wrapper_gen_tool', 'USE_BUILD_TREE')
# all_module_dirs: a list of all module directories in the build tree
self.all_module_dirs = [self.hw_dir.Dir(moduleList.topModule.buildPath)]
for module in synth_modules:
if (module.buildPath != moduleList.topModule.buildPath):
self.all_module_dirs += [self.hw_dir.Dir(module.buildPath)]
# all_build_dirs: the build (.bsc) sub-directory of all module directories
self.all_build_dirs = [d.Dir(self.TMP_BSC_DIR) for d in self.all_module_dirs]
# Include iface directories
self.all_module_dirs += iface_tool.getIfaceIncludeDirs(moduleList)
self.all_build_dirs += iface_tool.getIfaceLibDirs(moduleList)
# Add the top level build directory
self.all_build_dirs += [env.Dir(self.TMP_BSC_DIR)]
self.all_module_dirs += [self.hw_dir.Dir('include'),
self.hw_dir.Dir('include/awb/provides')]
# Full search path: all module and build directories
self.all_lib_dirs = self.all_module_dirs + self.all_build_dirs
all_build_dir_paths = [d.path for d in self.all_build_dirs]
self.ALL_BUILD_DIR_PATHS = ':'.join(all_build_dir_paths)
all_lib_dir_paths = [d.path for d in self.all_lib_dirs]
self.ALL_LIB_DIR_PATHS = ':'.join(all_lib_dir_paths)
# we need to annotate the module list with the
# bluespec-provided library files. Do so here.
bsv_tool.decorateBluespecLibraryCode(moduleList)
self.TMP_BSC_DIR = moduleList.env['DEFS']['TMP_BSC_DIR']
self.BUILD_LOGS_ONLY = moduleList.getAWBParam('bsv_tool', 'BUILD_LOGS_ONLY')
self.USE_BVI = moduleList.getAWBParam('bsv_tool', 'USE_BVI')
self.pipeline_debug = model.getBuildPipelineDebug(moduleList)
# Should we be building in events?
if (model.getEvents(moduleList) == 0):
bsc_events_flag = ' -D HASIM_EVENTS_ENABLED=False '
else:
bsc_events_flag = ' -D HASIM_EVENTS_ENABLED=True '
self.BSC_FLAGS = moduleList.getAWBParam('bsv_tool', 'BSC_FLAGS') + bsc_events_flag
moduleList.env.VariantDir(self.TMP_BSC_DIR, '.', duplicate=0)
moduleList.env['ENV']['BUILD_DIR'] = moduleList.env['DEFS']['BUILD_DIR'] # need to set the builddir for synplify
topo = moduleList.topologicalOrderSynth()
topo.reverse()
# Cleaning? Wipe out module temporary state. Do this before
# the topo pop to ensure that we don't leave garbage around at
# the top level.
if moduleList.env.GetOption('clean'):
for module in topo:
MODULE_PATH = get_build_path(moduleList, module)
os.system('cd '+ MODULE_PATH + '/' + self.TMP_BSC_DIR + '; rm -f *.ba *.c *.h *.sched *.log *.v *.bo *.str')
topo.pop() # get rid of top module.
## Python module that generates a wrapper to connect the exposed
## wires of all synthesis boundaries.
tree_builder = bsv_tool.BSVSynthTreeBuilder(self)
##
## Is this a normal build or a build in which only Bluespec dependence
## is computed?
##
if not moduleList.isDependsBuild:
##
## Normal build.
##
##
## Now that the "depends-init" build is complete we can
## continue with accurate inter-Bluespec file dependence.
## This build only takes place for the first pass object
## code generation. If the first pass li graph exists, it
## subsumes awb-style synthesis boundary generation.
##
for module in topo:
self.build_synth_boundary(moduleList, module)
## We are going to have a whole bunch of BA and V files coming.
## We don't yet know what they contain, but we do know that there
## will be |synth_modules| - 2 of them
if (not 'GEN_VERILOGS' in moduleList.topModule.moduleDependency):
moduleList.topModule.moduleDependency['GEN_VERILOGS'] = []
if (not 'GEN_BAS' in moduleList.topModule.moduleDependency):
moduleList.topModule.moduleDependency['GEN_BAS'] = []
## Having described the new build tree dependencies we can build
## the top module.
self.build_synth_boundary(moduleList, moduleList.topModule)
## Merge all synthesis boundaries using a tree? The tree reduces
## the number of connections merged in a single compilation, allowing
## us to support larger systems.
if self.USE_TREE_BUILD:
tree_builder.setupTreeBuild(moduleList, topo)
##
## Generate the global string table. Bluespec-generated global
## strings are stored in files by the compiler.
##
## The global string file will be generated in the top-level
## .bsc directory and a link to it will be added to the
## top-level directory.
##
all_str_src = []
#for module in topo + [moduleList.topModule]:
for module in moduleList.moduleList + topo + [moduleList.topModule]:
if('STR' in module.moduleDependency):
all_str_src.extend(module.moduleDependency['STR'])
if (self.BUILD_LOGS_ONLY == 0):
bsc_str = moduleList.env.Command(self.TMP_BSC_DIR + '/' + moduleList.env['DEFS']['APM_NAME'] + '.str',
all_str_src,
[ 'cat $SOURCES > $TARGET'])
strDep = moduleList.env.Command(moduleList.env['DEFS']['APM_NAME'] + '.str',
bsc_str,
[ 'ln -fs ' + self.TMP_BSC_DIR + '/`basename $TARGET` $TARGET' ])
moduleList.topDependency += [strDep]
if moduleList.env.GetOption('clean'):
print 'Cleaning depends-init...'
s = os.system('scons --clean depends-init')
else:
##
## Dependence build. The target of this build is "depens-init". No
## Bluespec modules will be compiled in this invocation of SCons.
## Only .depends-bsv files will be produced.
##
# We need to calculate some dependencies for the build
# tree. We could be clever and put this code somewhere
# rather than replicate it.
if self.USE_TREE_BUILD:
buildTreeDeps = {}
buildTreeDeps['GEN_VERILOGS'] = []
buildTreeDeps['GEN_BAS'] = []
#This is sort of a hack.
buildTreeDeps['WRAPPER_BSHS'] = ['awb/provides/soft_services.bsh']
buildTreeDeps['GIVEN_BSVS'] = []
buildTreeDeps['BA'] = []
buildTreeDeps['STR'] = []
buildTreeDeps['VERILOG'] = []
buildTreeDeps['BSV_LOG'] = []
buildTreeDeps['VERILOG_STUB'] = []
tree_module = Module( 'build_tree', ["mkBuildTree"], moduleList.topModule.buildPath,\
moduleList.topModule.name,\
[], moduleList.topModule.name, [], buildTreeDeps, platformModule=True)
tree_module.dependsFile = '.depends-build-tree'
moduleList.insertModule(tree_module)
tree_file_bo = get_build_path(moduleList, moduleList.topModule) + "/build_tree.bsv"
# sprinkle files to get dependencies right
bo_handle = open(tree_file_bo,'w')
# mimic AWB/leap-configure
bo_handle.write('//\n')
bo_handle.write('// Synthesized compilation file for module: build_tree\n')
bo_handle.write('//\n')
bo_handle.write('// This file was created by BSV.py\n')
bo_handle.write('//\n')
bo_handle.write('`define BUILDING_MODULE_build_tree\n')
bo_handle.write('`include "build_tree_Wrapper.bsv"\n')
bo_handle.close()
# Calling generateWrapperStub will write out default _Wrapper.bsv
# and _Log.bsv files for build tree. However, these files
# may already exists, and, in the case of build_tree_Wrapper.bsv,
# have meaningful content. Fortunately, generateWrapperStub
# will not over write existing files.
wrapper_gen_tool.generateWrapperStub(moduleList, tree_module)
wrapper_gen_tool.generateAWBCompileWrapper(moduleList, tree_module)
topo.append(tree_module)
deps = []
useDerived = True
first_pass_LI_graph = wrapper_gen_tool.getFirstPassLIGraph()
if (not first_pass_LI_graph is None):
useDerived = False
# we also need to parse the platform_synth file in th
platform_synth = get_build_path(moduleList, moduleList.topModule) + "/" + moduleList.localPlatformName + "_platform_synth.bsv"
platform_deps = ".depends-platform"
deps += self.compute_dependence(moduleList, moduleList.topModule, useDerived, fileName=platform_deps, targetFiles=[platform_synth])
# If we have an LI graph, we need to construct and compile
# several LI wrappers. do that here.
# include all the dependencies in the graph in the wrapper.
li_wrappers = []
tree_base_path = get_build_path(moduleList, moduleList.topModule)
liGraph = LIGraph([])
firstPassGraph = first_pass_LI_graph
# We should ignore the 'PLATFORM_MODULE'
liGraph.mergeModules([ module for module in getUserModules(firstPassGraph) if module.getAttribute('RESYNTHESIZE') is None])
for module in sorted(liGraph.graph.nodes(), key=lambda module: module.name):
wrapper_import_path = tree_base_path + '/' + module.name + '_Wrapper.bsv'
li_wrappers.append(module.name + '_Wrapper.bsv')
wrapper_import_handle = open(wrapper_import_path, 'w')
wrapper_import_handle.write('import Vector::*;\n')
wrapper_gen_tool.generateWellKnownIncludes(wrapper_import_handle)
wrapper_gen_tool.generateBAImport(module, wrapper_import_handle)
wrapper_import_handle.close()
platform_deps = ".depends-" + module.name
deps += self.compute_dependence(moduleList, moduleList.topModule, useDerived, fileName=platform_deps, targetFiles=[wrapper_import_path])
for module in topo + [moduleList.topModule]:
# for object import builds no Wrapper code will be included. remove it.
deps += self.compute_dependence(moduleList, module, useDerived, fileName=module.dependsFile)
moduleList.topDependsInit += deps
"mod_code": "cmpu1004",
},
{
"student_no": "c4444",
"mod_code": "cmpu1005",
},
]
for student in students:
try:
new_student = Student(**student)
session.add(new_student)
session.commit()
except:
pass
for module in modules:
try:
new_module = Module(**module)
session.add(new_module)
session.commit()
except:
pass
for entry in student_modules:
try:
new_entry = StudentModule(**entry)
session.add(new_entry)
session.commit()
except:
pass
def __init__(self, moduleList):
# some definitions used during the bsv compilation process
env = moduleList.env
self.moduleList = moduleList
self.hw_dir = env.Dir(moduleList.env['DEFS']['ROOT_DIR_HW'])
self.TMP_BSC_DIR = env['DEFS']['TMP_BSC_DIR']
synth_modules = moduleList.synthBoundaries()
self.USE_TREE_BUILD = moduleList.getAWBParam('wrapper_gen_tool',
'USE_BUILD_TREE')
# all_module_dirs: a list of all module directories in the build tree
self.all_module_dirs = [
self.hw_dir.Dir(moduleList.topModule.buildPath)
]
for module in synth_modules:
if (module.buildPath != moduleList.topModule.buildPath):
self.all_module_dirs += [self.hw_dir.Dir(module.buildPath)]
# all_build_dirs: the build (.bsc) sub-directory of all module directories
self.all_build_dirs = [
d.Dir(self.TMP_BSC_DIR) for d in self.all_module_dirs
]
# Include iface directories
self.all_module_dirs += iface_tool.getIfaceIncludeDirs(moduleList)
self.all_build_dirs += iface_tool.getIfaceLibDirs(moduleList)
# Add the top level build directory
self.all_build_dirs += [env.Dir(self.TMP_BSC_DIR)]
self.all_module_dirs += [
self.hw_dir.Dir('include'),
self.hw_dir.Dir('include/awb/provides')
]
# Full search path: all module and build directories
self.all_lib_dirs = self.all_module_dirs + self.all_build_dirs
all_build_dir_paths = [d.path for d in self.all_build_dirs]
self.ALL_BUILD_DIR_PATHS = ':'.join(all_build_dir_paths)
all_lib_dir_paths = [d.path for d in self.all_lib_dirs]
self.ALL_LIB_DIR_PATHS = ':'.join(all_lib_dir_paths)
# we need to annotate the module list with the
# bluespec-provided library files. Do so here.
bsv_tool.decorateBluespecLibraryCode(moduleList)
self.TMP_BSC_DIR = moduleList.env['DEFS']['TMP_BSC_DIR']
self.BUILD_LOGS_ONLY = moduleList.getAWBParam('bsv_tool',
'BUILD_LOGS_ONLY')
self.USE_BVI = moduleList.getAWBParam('bsv_tool', 'USE_BVI')
self.pipeline_debug = model.getBuildPipelineDebug(moduleList)
# Should we be building in events?
if (model.getEvents(moduleList) == 0):
bsc_events_flag = ' -D HASIM_EVENTS_ENABLED=False '
else:
bsc_events_flag = ' -D HASIM_EVENTS_ENABLED=True '
self.BSC_FLAGS = moduleList.getAWBParam('bsv_tool',
'BSC_FLAGS') + bsc_events_flag
moduleList.env.VariantDir(self.TMP_BSC_DIR, '.', duplicate=0)
moduleList.env['ENV']['BUILD_DIR'] = moduleList.env['DEFS'][
'BUILD_DIR'] # need to set the builddir for synplify
topo = moduleList.topologicalOrderSynth()
topo.reverse()
# Cleaning? Wipe out module temporary state. Do this before
# the topo pop to ensure that we don't leave garbage around at
# the top level.
if moduleList.env.GetOption('clean'):
for module in topo:
MODULE_PATH = get_build_path(moduleList, module)
os.system('cd ' + MODULE_PATH + '/' + self.TMP_BSC_DIR +
'; rm -f *.ba *.c *.h *.sched *.log *.v *.bo *.str')
topo.pop() # get rid of top module.
## Python module that generates a wrapper to connect the exposed
## wires of all synthesis boundaries.
tree_builder = bsv_tool.BSVSynthTreeBuilder(self)
##
## Is this a normal build or a build in which only Bluespec dependence
## is computed?
##
if not moduleList.isDependsBuild:
##
## Normal build.
##
##
## Now that the "depends-init" build is complete we can
## continue with accurate inter-Bluespec file dependence.
## This build only takes place for the first pass object
## code generation. If the first pass li graph exists, it
## subsumes awb-style synthesis boundary generation.
##
for module in topo:
self.build_synth_boundary(moduleList, module)
## We are going to have a whole bunch of BA and V files coming.
## We don't yet know what they contain, but we do know that there
## will be |synth_modules| - 2 of them
if (not 'GEN_VERILOGS' in moduleList.topModule.moduleDependency):
moduleList.topModule.moduleDependency['GEN_VERILOGS'] = []
if (not 'GEN_BAS' in moduleList.topModule.moduleDependency):
moduleList.topModule.moduleDependency['GEN_BAS'] = []
## Having described the new build tree dependencies we can build
## the top module.
self.build_synth_boundary(moduleList, moduleList.topModule)
## Merge all synthesis boundaries using a tree? The tree reduces
## the number of connections merged in a single compilation, allowing
## us to support larger systems.
if self.USE_TREE_BUILD:
tree_builder.setupTreeBuild(moduleList, topo)
##
## Generate the global string table. Bluespec-generated global
## strings are stored in files by the compiler.
##
## The global string file will be generated in the top-level
## .bsc directory and a link to it will be added to the
## top-level directory.
##
all_str_src = []
#for module in topo + [moduleList.topModule]:
for module in moduleList.moduleList + topo + [
moduleList.topModule
]:
if ('STR' in module.moduleDependency):
all_str_src.extend(module.moduleDependency['STR'])
if (self.BUILD_LOGS_ONLY == 0):
bsc_str = moduleList.env.Command(
self.TMP_BSC_DIR + '/' +
moduleList.env['DEFS']['APM_NAME'] + '.str', all_str_src,
['cat $SOURCES > $TARGET'])
strDep = moduleList.env.Command(
moduleList.env['DEFS']['APM_NAME'] + '.str', bsc_str, [
'ln -fs ' + self.TMP_BSC_DIR +
'/`basename $TARGET` $TARGET'
])
moduleList.topDependency += [strDep]
if moduleList.env.GetOption('clean'):
print 'Cleaning depends-init...'
s = os.system('scons --clean depends-init')
else:
##
## Dependence build. The target of this build is "depens-init". No
## Bluespec modules will be compiled in this invocation of SCons.
## Only .depends-bsv files will be produced.
##
# We need to calculate some dependencies for the build
# tree. We could be clever and put this code somewhere
# rather than replicate it.
if self.USE_TREE_BUILD:
buildTreeDeps = {}
buildTreeDeps['GEN_VERILOGS'] = []
buildTreeDeps['GEN_BAS'] = []
#This is sort of a hack.
buildTreeDeps['WRAPPER_BSHS'] = [
'awb/provides/soft_services.bsh'
]
buildTreeDeps['GIVEN_BSVS'] = []
buildTreeDeps['BA'] = []
buildTreeDeps['STR'] = []
buildTreeDeps['VERILOG'] = []
buildTreeDeps['BSV_LOG'] = []
buildTreeDeps['VERILOG_STUB'] = []
tree_module = Module( 'build_tree', ["mkBuildTree"], moduleList.topModule.buildPath,\
moduleList.topModule.name,\
[], moduleList.topModule.name, [], buildTreeDeps, platformModule=True)
tree_module.dependsFile = '.depends-build-tree'
moduleList.insertModule(tree_module)
tree_file_bo = get_build_path(
moduleList, moduleList.topModule) + "/build_tree.bsv"
# sprinkle files to get dependencies right
bo_handle = open(tree_file_bo, 'w')
# mimic AWB/leap-configure
bo_handle.write('//\n')
bo_handle.write(
'// Synthesized compilation file for module: build_tree\n')
bo_handle.write('//\n')
bo_handle.write('// This file was created by BSV.py\n')
bo_handle.write('//\n')
bo_handle.write('`define BUILDING_MODULE_build_tree\n')
bo_handle.write('`include "build_tree_Wrapper.bsv"\n')
bo_handle.close()
# Calling generateWrapperStub will write out default _Wrapper.bsv
# and _Log.bsv files for build tree. However, these files
# may already exists, and, in the case of build_tree_Wrapper.bsv,
# have meaningful content. Fortunately, generateWrapperStub
# will not over write existing files.
wrapper_gen_tool.generateWrapperStub(moduleList, tree_module)
wrapper_gen_tool.generateAWBCompileWrapper(
moduleList, tree_module)
topo.append(tree_module)
deps = []
useDerived = True
first_pass_LI_graph = wrapper_gen_tool.getFirstPassLIGraph()
if (not first_pass_LI_graph is None):
useDerived = False
# we also need to parse the platform_synth file in th
platform_synth = get_build_path(
moduleList, moduleList.topModule
) + "/" + moduleList.localPlatformName + "_platform_synth.bsv"
platform_deps = ".depends-platform"
deps += self.compute_dependence(moduleList,
moduleList.topModule,
useDerived,
fileName=platform_deps,
targetFiles=[platform_synth])
# If we have an LI graph, we need to construct and compile
# several LI wrappers. do that here.
# include all the dependencies in the graph in the wrapper.
li_wrappers = []
tree_base_path = get_build_path(moduleList,
moduleList.topModule)
liGraph = LIGraph([])
firstPassGraph = first_pass_LI_graph
# We should ignore the 'PLATFORM_MODULE'
liGraph.mergeModules([
module for module in getUserModules(firstPassGraph)
if module.getAttribute('RESYNTHESIZE') is None
])
for module in sorted(liGraph.graph.nodes(),
key=lambda module: module.name):
wrapper_import_path = tree_base_path + '/' + module.name + '_Wrapper.bsv'
li_wrappers.append(module.name + '_Wrapper.bsv')
wrapper_import_handle = open(wrapper_import_path, 'w')
wrapper_import_handle.write('import Vector::*;\n')
wrapper_gen_tool.generateWellKnownIncludes(
wrapper_import_handle)
wrapper_gen_tool.generateBAImport(module,
wrapper_import_handle)
wrapper_import_handle.close()
platform_deps = ".depends-" + module.name
deps += self.compute_dependence(
moduleList,
moduleList.topModule,
useDerived,
fileName=platform_deps,
targetFiles=[wrapper_import_path])
for module in topo + [moduleList.topModule]:
# for object import builds no Wrapper code will be included. remove it.
deps += self.compute_dependence(moduleList,
module,
useDerived,
fileName=module.dependsFile)
moduleList.topDependsInit += deps
